아래 의사 코드를 통해 ASCII 홀수 / 짝수 암호 를 정의합니다 .

Define 'neighbor' as the characters adjacent to the current letter in the string

If the one of the neighbors is out of bounds of the string, treat it as \0 or null

Take an input string

For each letter in the string, do
  If the 0-based index of the current letter is even, then
    Use the binary-or of the ASCII codes of both its neighbors
  Else
    If the ASCII code of the current letter is odd, then
      Use the binary-or of itself plus the left neighbor
    Else
      Use the binary-or of itself plus the right neighbor
  In all cases,
    Convert the result back to ASCII and return it
  If this would result in a code point 127 or greater to be converted, then
    Instead return a space

Join the results of the For loop back into one string and output it

예를 들어 input Hello의 경우 출력은입니다 emmol.

• H에 회전 \0 | 'e'하는이e
• (가) e에 회전 'e' | 'l', 또는 101 | 108이다, 109또는m
• 첫 번째 l는 101 | 108또는m
• 두번째 l로 회전 108 | 111된다 111거나o
• 로 o바뀌 108 | \0거나l

입력

• 적절한 형식 의 인쇄 가능한 ASCII 문자로만 구성된 문장 .
• 문장에는 마침표, 공백 및 기타 문장 부호가있을 수 있지만 한 줄만됩니다.
• 문장의 길이는 3 자 이상입니다.

산출

• 위에서 설명한 규칙에 따라 결과 암호는 문자열 또는 출력으로 반환됩니다.

규칙

• 전체 프로그램 또는 기능이 허용됩니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

예

한 줄에 입력하고 다음에 출력합니다. 빈 줄은 예를 분리합니다.

Hello
emmol

Hello, World!
emmol, ww~ved

PPCG
PSWG

Programming Puzzles and Code Golf
r wogsmmoonpuu ~ meannncoooeggonl

abcdefghijklmnopqrstuvwxyz
bcfefgnijknmno~qrsvuvw~yzz

!abcdefghijklmnopqrstuvwxyz
aaccgeggoikkomoo qsswuww yy

Test 123 with odd characters. R@*SKA0z8d862
euutu133www|todddchizsscguwssr`jS{SK{z~|v66

젤리 , 33 31 바이트

2ịḂị|2\
|ṚḢ,Ç
O0,0jṡ3µÇ€⁸JḂ¤ị"Ọ

더 짧아 질 수있는 간단한 접근 방식.

온라인으로 사용해보십시오!

펄, 63 62 바이트

에 +4 포함 -lp

STDIN에 입력하십시오

oddeven.pl:

#!/usr/bin/perl -lp
s%.%(--$|?$n|$':$&|(ord$&&1?$n:$'))&($n=$&,~v0)%eg;y;\x7f-\xff; ;

이것은 표시된대로 작동하지만 청구 된 점수를 얻으려면 최종 및 개행 없이 파일에 넣어야 ;하며 \xhh이스케이프는 리터럴 값으로 대체해야합니다. 위 코드를 파일에 넣고 다음을 실행하여이 작업을 수행 할 수 있습니다.

perl -0pi -e 's/\\x(..)/chr hex $1/eg;s/;\n$//' oddeven.pl

파이썬 2, 138131 바이트

s="\0%s\0"%input();r=''
for i in range(len(s)-2):L,M,R=map(ord,s[i:i+3]);a=i%2and[R,L][M%2]|M or L|R;r+=chr(a*(a<127)or 32)
print r

온라인으로 사용해보십시오 (모든 테스트 사례 포함)

덜 골프 :

def f(s):
    s="\0%s\0"%s
    r=''
    for i in range(1,len(s)-1):
        if i%2: # even (parity is changed by adding \x00 to the front)
            a=ord(s[i-1]) | ord(s[i+1])
        else:   # odd
            a=ord(s[i])
            if a%2: # odd
                a|=ord(s[i-1])
            else:   # even
                a|=ord(s[i+1])
        r+=chr(a if a<127 else 32)
    print r

온라인으로 사용해보십시오 (ungolfed)

\x00비트 또는 오링 중에 걱정할 필요가 없도록 문자열의 양쪽에 추가 합니다. 패리티 규칙에 따라 문자열의 원래 문자를 따라 비트 연산을 수행하고 결과에 추가합니다.

C-101 바이트

i,k;f(char*p){for(i=0;*p;++p,++i)putchar((k=i&1?*p&1?*p|p[-1]:*p|p[1]:i?p[-1]|p[1]:p[1])<127?k:' ');}

C의 문자열은 null로 끝나기 때문에 문자열의 마지막 항목인지 확인할 필요조차 없습니다.

설명

오히려 간단합니다.

& 1을 사용하여 if / elses를 대체 할 홀수 / 짝수 및 삼항 표현식을 테스트하십시오. 필요한 괄호 수를 줄이려면 char * p를 늘리십시오.

Mathematica, 152 바이트

FromCharacterCode[BitOr@@Which[OddQ@Max@#2,#~Drop~{2},OddQ@#[[2]],Most@#,True,Rest@#]/._?(#>126&)->32&~MapIndexed~Partition[ToCharacterCode@#,3,1,2,0]]&

설명

ToCharacterCode@#

문자열을 ASCII 코드로 변환

Partition[...,3,1,2,0]

ASCII 코드를 길이 3으로 분할하고 0으로 채워진 파티션 1을 오프셋합니다.

...~MapIndexed~...

각 파티션에 기능을 적용합니다.

Which[...]

If...else if... else에 티카 .

OddQ@Max@#2

인덱스 (# 2)가 홀수인지 확인합니다. ( Max평화 용); Mathematica 지수는 1부터 시작하기 때문에 OddQ여기서는 사용 하지 않았습니다.EvenQ

Drop[#,{2}]

왼쪽 및 오른쪽 이웃의 ASCII 코드를 사용합니다.

OddQ@#[[2]]

해당 문자의 ASCII 코드가 홀수인지 확인합니다.

Most@#

문자 및 왼쪽 인접 문자의 ASCII 코드를 사용합니다.

Rest@#

문자와 오른쪽 이웃의 ASCII 코드를 사용합니다.

BitOr

또는 작업을 적용합니다.

/._?(#>126&)->32

126보다 큰 모든 숫자를 32 (공백)로 바꿉니다.

FromCharacterCode

ASCII 코드를 문자로 다시 변환하고 결합합니다.

루비 133 128 108 106 바이트

Jordan은 20 바이트를 절약하고 cia_rana는 2 바이트를 절약하도록 도와주었습니다. :)

->s{p s[-i=-1]+s.bytes.each_cons(3).map{|x,y,z|i+=1;a=i%2>0?x|z :y%2>0?y|x :y|z;a>126?' ':a.chr}*""+s[-2]}

s 입력 문자열로 사용됩니다.

의 출력 예 s="Test 123 with odd characters. R@*SKA0z8d862":

"euutu133www|todddchizsscguwssr`jS{SK{z~|v66"

설명

위의 코드는 읽을 수 없으므로 여기에 설명이 있습니다. 코드는 일종의 해키입니다. 루비를 처음 접했기 때문에 더 짧은 방법이 있습니다. :)

b=s[1] # for the first character we always use the right neighbour
       # because `\0 | x` will always return x any way. 0 is the
       # left neighbour and x is the right neigbour
s.bytes.each_cons(3).with_index{|c,i| # oh boy, first we convert the string to ascii with each_byte
                                          # we then traverse the resulting array with three elements at
                                          # a time (so for example if s equals "Hello", c will be equal
                                          # to [72, 101, 108])
  if (i+1) % 2 < 1 # if the middle letter (which is considered our current letter) is even
    a = c[0] | c[2] # we use the result of binary-or of its neighbours
  else
    if c[1] % 2 > 0 # if the code of the current letter is odd
      a = c[1] | c[0] # we use the result of binary-or of itself and its left neighbour
    else
      a = c[1] | c[2] # we use the result of binary-or of itself and its right neighbour
    end
  end
  if a>126
    b<<' ' # if the result we use is greater or equal to 127 we use a space
  else
    b<<a.chr # convert the a ascii value back to a character
  end
}
p b+s[-2] # same as the first comment but now we know that x | \0 will always be x
          # this time x is the last characters left neighbour

J, 42 바이트

4:u:3({.OR{:)`((2|1&{){2:OR/\|.)\0,~0,3&u:

J의 동사가 `infix와 같은 특정 부사에 대해 gerund 를 사용하여 교대로 적용 할 수있는 특성을 사용합니다 \.

용법

   f =: 4:u:3({.OR{:)`((2|1&{){2:OR/\|.)\0,~0,3&u:
   f 'Hello'
emmol
   f 'Hello, World!'
emmol,ww~ved
   f 'PPCG'
PSWG
   f 'Programming Puzzles and Code Golf'
rwogsmmoonpuu~meannncoooeggonl
   f 'abcdefghijklmnopqrstuvwxyz'
bcfefgnijknmno~qrsvuvw~yzz
   f '!abcdefghijklmnopqrstuvwxyz'
aaccgeggoikkomooqsswuwwyy
   f 'Test 123 with odd characters. R@*SKA0z8d862'
euutu133www|todddchizsscguwssr`jS{SK{z~|v66

설명

4:u:3({.OR{:)`((2|1&{){2:OR/\|.)\0,~0,3&u:  Input: string S
                                      3&u:  Convert each char to an ordinal
                                    0,      Prepend 0
                                 0,~        Append 0
    3                           \           For each slice of size 3
     (      )`                                For the first slice (even-index)
          {:                                    Get the tail
      {.                                        Get the head
        OR                                      Bitwise OR the head and tail
             `(                )              For the second slice (odd-index)
                             |.                 Reverse the slice
                       2:   \                   For each pair
                         OR/                      Reduce using bitwise OR
                  1&{                           Get the middle value of the slice
                2|                              Take it modulo 2
                      {                         Index into the bitwise OR pairs and select
                                              Repeat cyclically for the remaining slices
4:u:                                        Convert each ordinal back to a char and return

자바 스크립트 (ES6) 125 118 114 바이트

쩔쩔 매게 긴하지만, charCodeAt그리고 String.fromCharCode혼자 것은 29 바이트입니다. :-/

s=>[...s].map((_,i)=>String.fromCharCode((x=(C=i=>s.charCodeAt(i))((i-1)|1)|C(i+1-2*(C(i)&i&1)))>126?32:x)).join``

작동 원리

위치에있는 각 문자 i는 다음 공식으로 변환되며 한 번에 모든 규칙을 포함합니다.

C((i - 1) | 1) | C(i + 1 - 2 * (C(i) & i & 1))

여기서 C(n)입력 문자열의 n 번째 문자의 ASCII 코드를 반환합니다.

데모

let f =
    
s=>[...s].map((_,i)=>String.fromCharCode((x=(C=i=>s.charCodeAt(i))((i-1)|1)|C(i+1-2*(C(i)&i&1)))>126?32:x)).join``

console.log(f("Hello"));
console.log(f("Hello, World!"));
console.log(f("PPCG"));
console.log(f("Programming Puzzles and Code Golf"));
console.log(f("abcdefghijklmnopqrstuvwxyz"));
console.log(f("!abcdefghijklmnopqrstuvwxyz"));
console.log(f("Test 123 with odd characters. R@*SKA0z8d862"));

PHP, 107 97 바이트

아마 골프를 타기 쉽다.

for(;$i<strlen($s=$argv[1]);$i++)echo chr(ord($s[$i-1+$i%2])|ord($s[$i+1-2*($i&ord($s[$i])&1)]));

C #, 145 바이트

s=>{var r=s[1]+"";int i=1,l=s.Length,c;for(;i<l;i++){c=i>l-2?0:s[i+1];c=i%2<1?s[i-1]|c:s[i]|(s[i]%2>0?s[i-1]:c);r+=c>'~'?' ':(char)c;}return r;};

ungolfed 방법 및 테스트 사례가 포함 된 전체 프로그램 :

using System;

namespace ASCIIOddEvenCipher
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,string>f= s=>
            {
                var r = s[1] + "";
                int i = 1, l = s.Length, c;
                for(;i < l; i++)
                {
                    c = i>l-2 ? 0 : s[i+1];
                    c = i%2<1 ? s[i-1]|c : s[i]|(s[i]%2>0 ? s[i-1] : c);
                    r += c > '~' ? ' ' : (char)c;
                }
                return r;
            };

            //test cases:
            Console.WriteLine(f("Hello"));  //emmol
            Console.WriteLine(f("Hello, World!"));  //emmol, ww~ved
            Console.WriteLine(f("PPCG"));   //PSWG
            Console.WriteLine(f("Programming Puzzles and Code Golf"));  //r wogsmmoonpuu ~ meannncoooeggonl
            Console.WriteLine(f("abcdefghijklmnopqrstuvwxyz")); //bcfefgnijknmno~qrsvuvw~yzz
            Console.WriteLine(f("!abcdefghijklmnopqrstuvwxyz"));    //aaccgeggoikkomoo qsswuww yy
            Console.WriteLine(f("Test 123 with odd characters. R@*SKA0z8d862"));    //euutu133www|todddchizsscguwssr`jS{SK{z~|v66
        }
    }
}

이것은 내가 생각했던 것보다 길다.