Nous définirons le chiffre impair / pair ASCII via le pseudocode ci-dessous:

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

Par exemple, pour l'entrée Hello, la sortie est emmol, puisque

• Les Hvirages vers \0 | 'e'lesquelse
• Les evirages vers 'e' | 'l', ou 101 | 108, qui est 109oum
• Le premier lse tourne également vers 101 | 108oum
• Le second se ltourne vers 108 | 111, qui est 111ouo
• Les ovirages en 108 | \0, oul

Contribution

• Une phrase composée uniquement de caractères ASCII imprimables, dans tout format approprié .
• La phrase peut avoir des points, des espaces et d'autres signes de ponctuation, mais ne comportera jamais qu'une seule ligne.
• La phrase comportera au moins trois caractères.

Production

• Le chiffrement résultant, basé sur les règles décrites ci-dessus, est retourné sous forme de chaîne ou de sortie.

Les règles

• Un programme complet ou une fonction sont acceptables.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

Entrée sur une ligne, sortie sur ce qui suit. Des lignes vides séparent les exemples.

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

Gelée , 33 31 octets

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

Une approche directe qui peut sûrement être raccourcie.

Essayez-le en ligne!

Perl, 63 62 octets

Comprend +4 pour -lp

Donnez votre avis sur STDIN

oddeven.pl:

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

Cela fonctionne comme indiqué, mais pour obtenir le score revendiqué, cela doit être mis dans un fichier sans final ;et newline et les \xhhéchappements doivent être remplacés par leurs valeurs littérales. Vous pouvez le faire en mettant le code ci-dessus dans le fichier et en exécutant:

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

Python 2, 138 131 octets

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

Essayez-le en ligne (contient tous les cas de test)

Moins golfé:

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

Essayez-le en ligne (non golfé)

J'ajoute \x00aux deux côtés de la chaîne afin de ne pas avoir à m'en soucier pendant le bit-oring. Je boucle le long des caractères d'origine de la chaîne, en effectuant des opérations au niveau du bit et en les ajoutant au résultat, en suivant les règles de parité.

C - 101 octets

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:' ');}

Nous n'avons même pas besoin de vérifier s'il s'agit du dernier élément de la chaîne car les chaînes en C sont terminées par null.

Explication

Assez simple:

Utilisez & 1 pour tester les expressions impaires / planes et ternaires pour remplacer if / elses. Incrémentez le caractère * p pour réduire le nombre de crochets requis.

Mathematica, 152 octets

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

Explication

ToCharacterCode@#

Convertit une chaîne en codes ASCII

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

Partitionne les codes ASCII en longueur 3, décalez 1 partition, avec des 0 remplis.

...~MapIndexed~...

Applique une fonction pour chaque partition.

Which[...]

If...else if... elseen Mathematica .

OddQ@Max@#2

Vérifie si l'index (# 2) est impair. ( Maxest pour l'aplatissement); puisque l' index Mathematica commence à 1, je l'ai utilisé OddQici, pasEvenQ

Drop[#,{2}]

Prend les codes ASCII des voisins gauche et droit.

OddQ@#[[2]]

Vérifie si le code ASCII du caractère correspondant est impair.

Most@#

Prend les codes ASCII du caractère et du voisin gauche.

Rest@#

Prend les codes ASCII du caractère et du bon voisin.

BitOr

Applique ou opération.

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

Remplace tous les nombres supérieurs à 126 par 32 (espace).

FromCharacterCode

Convertit le code ASCII en caractères et les joint.

Ruby 133 128 108 106 octets

Jordan m'a aidé à économiser 20 octets et cia_rana m'a aidé à économiser 2 octets :)

->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 est prise comme chaîne d'entrée.

Exemple de sortie avec s="Test 123 with odd characters. R@*SKA0z8d862":

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

Explication

Le code ci-dessus est très illisible, voici donc une explication. Le code est un peu hacky, je suis nouveau sur Ruby, donc je parie qu'il y a un moyen plus court de le faire :)

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 octets

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

Utilise la propriété selon laquelle les verbes en J peuvent être appliqués de manière alternée en utilisant un gérondif `pour certains adverbes tels que infix\ .

Usage

   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

Explication

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 octets

Embarrassant de temps, mais charCodeAt et String.fromCharCodeseuls sont 29 octets. : - /

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

Comment ça fonctionne

Chaque caractère à la position iest traduit avec la formule suivante, qui couvre toutes les règles à la fois:

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

où C(n)renvoie le code ASCII du nième caractère de la chaîne d'entrée.

Démo

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 octets

probablement golfable.

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 octets

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

Programme complet avec méthode non golfée et cas de test:

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

Cela s'est avéré plus long que je ne le pensais ...