我们将通过以下伪代码定义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字符组成的句子，格式任意。
• 该句子可能有句点，空格和其他标点符号，但只能是一行。
• 该句子的长度至少为三个字符。

输出量

• 根据上述规则，生成的密码将作为字符串或输出返回。

规则

• 完整的程序或功能都是可以接受的。
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此所有常用的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

例子

输入一行，然后输出。空白行分隔示例。

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Ḃ¤ị"Ọ

肯定可以缩短的直接方法。

在线尝试！

Perl，63 62字节

包括+4 -lp

在STDIN上输入

oddeven.pl：

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

如图所示，该方法起作用，但是要获得要求的分数，必须将其放入没有 final ;和换行符的文件中，并且\xhh转义符必须用其文字值替换。您可以通过将上面的代码放入文件中并运行以下命令来执行此操作：

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

Python 2中，138个 131字节

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

在线试用（已解冻）

我\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，偏移量为1分区，并填充0。

...~MapIndexed~...

为每个分区应用一个函数。

Which[...]

If...else if... else在Mathematica中。

OddQ@Max@#2

检查索引（＃2）是否为奇数。（Max用于展平）；因为Mathematica索引从1开始，所以我OddQ在这里使用EvenQ

Drop[#,{2}]

接受左右邻居的ASCII码。

OddQ@#[[2]]

检查对应字符的ASCII码是否为奇数。

Most@#

接受字符和左邻居的ASCII码。

Rest@#

接受字符和右邻居的ASCII码。

BitOr

应用或操作。

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

用32（空格）替换所有大于126的数字。

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"

说明

上面的代码非常不可读，因此这里有一个解释。该代码有点hacky，我是ruby的新手，所以我敢打赌，这样做的方法更短:)

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:

使用以下属性：可以`对某些副词（例如infix）使用gerund 来交替使用J中的动词\。

用法

   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

的JavaScript（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;};

完整的程序，包含未使用的方法和测试用例：

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
        }
    }
}

结果比我想象的要长。