Le problème:

Deux agents secrets ennemis ont conçu une merveilleuse méthode de communication (pour vous)!

Voici comment fonctionne le processus de cryptage:

1) Prenez les équivalents ascii de chaque lettre. (Aucun espace, chiffre ou ponctuation n'est envoyé)

2) Pour chaque lettre du message, l'équivalent ascii de celle-ci et la lettre qui la suit (si elle existe, si ce n'est pas le cas, elle doit être considérée comme 0), sont multipliées (ce produit est stocké dans un tableau / liste) et additionné (ce nombre est également stocké dans une liste différente).

3) Les deux listes (des sommes et des produits) sont réunies (la liste des sommes, puis la liste des multiples, dans le même tableau) et transmises.

Vous devez écrire le plus petit programme capable d'inverser ce processus et de décrypter les messages envoyés dans ce format!

Exemples de paires d'entrée et de sortie:

[173, 209, 216, 219, 198, 198, 225, 222, 208, 100, 7272, 10908, 11664, 11988, 9657, 9657, 12654, 12312, 10800, 0] -> “HelloWorld”
[131, 133, 164, 195, 197, 99, 4290, 4422, 6499, 9506, 9702, 0] -> “ABCabc”

Il s'agit de code-golf , donc la plus petite solution en octets l'emporte.

Les messages d'erreur sont autorisés.

Votre programme peut recevoir soit une liste / un tableau unidimensionnel, soit une chaîne séparée par des virgules, si vous le spécifiez dans votre soumission. La valeur par défaut est un tableau / liste.

Husk , 7 6 octets

mcĠ≠←½

Essayez-le en ligne! Selon la documentation, le début mne devrait pas être nécessaire, mais il semble y avoir un bogue actuellement.

Edit: -1 octet grâce à Zgarb!

Explication:

     ½ -- split input list into half
    ←  -- take first list
  Ġ≠   -- subtract each list element from the previous one
mc     -- convert list of code points to string

brainfuck , 66 octets

,[>>>+<[-<+>>-<]<[->+<],]>[<<,>>[-<+>]<-]<<<[>[-<->>+<]<<]>.>>[.>]

L'entrée est la chaîne chiffrée. Suppose des cellules de taille infinie et 0 sur EOF.

Comment ça fonctionne:

,[>>>+<[-<+>>-<]<[->+<],] Gets input and the number of characters divided by 2
>[<<,>>[-<+>]<-]<<< Remove the second half of the string (the multiplication part)
[>[-<->>+<]<<] Subtract each character from the previous one, while keeping a copy of the previous one.
>.>>[.>] Print the characters

Haskell , 45 35 octets

map toEnum.scanr1(-).fst.span(<245)

Essayez-le en ligne!

Explication

• fst.span(<245)prend tous les nombres du début de la liste qui sont inférieurs à 245. Ce ne sont que les nombres de la partie de sommation, car la plus grande sommation possible est z + z = 122 + 122 = 244et le plus petit produit possible est A * A = 65 * 65 = 4225.
• scanr1(-)prend la dernière valeur de la liste et l'utilise comme accumulateur initial. D'arrière en avant, chaque élément de la liste est soustrait par l'accumulateur actuel et le résultat est utilisé comme accumulateur suivant et ajouté à une liste.
• map toEnum remplace chaque numéro de la liste par le caractère correspondant pour recréer la chaîne.

Gelée , 9 octets

œs2ḢUạ\ỌU

Essayez-le en ligne! ou Vérifiez les deux cas de test.

Alternative.

Explication

œs2ḢUạ \ ỌU || Programme complet.

œs2 || Divisé en deux parties, la première étant plus longue si nécessaire.
   Ḣ || Obtenez la tête (premier élément).
    U || Sens inverse.
     ạ \ || Réduction cumulative par soustraction.
       Ọ || Convertissez des points de code en caractères.
        U || Et inversez à nouveau.

Python 2 , 72 octets

a=input();p=0;r=''
for v in a[len(a)/2-1::-1]:r=chr(v-p)+r;p=v-p
print r

Essayez-le en ligne!

Python 2 , 92 octets

lambda C:"".join(chr(sum((-1)**i*C[j+i]for i in range(len(C)/2-j)))for j in range(len(C)/2))

Essayez-le en ligne!

Gelée , 11 octets

œs2Ḣḅ-$ÐƤAỌ

Un lien monadique prenant une liste d'entiers et renvoyant une liste de caractères.

Essayez-le en ligne!

Comment?

œs2Ḣḅ-$ÐƤAỌ - Link: list of integers     e.g. [210,211,201,101,10989,11100,10100,0]
  2         - literal two                     2
œs          - split into equal parts          [[210,211,201,101],[10989,11100,10100,0]]
   Ḣ        - head                            [210,211,201,101]
       ÐƤ   - for postfixes:                  [210,211,201,101],[211,201,101],[201,101],[101]
      $     -   last two links as a monad:
     -      -     literal minus one           -1
    ḅ       -     convert from base           -99              ,111          ,-100      ,101
         A  - absolute value (vectorises)     [99,111,100,101]
          Ọ - convert to ordinal (vectorises) "code"

Pyt , 60 octets

←ĐĐŁ₂⁻⦋⇹ĐŁřĐŁ₂>*ž0`ŕĐĐŁ⁻⦋3ȘĐ4Ș3Ș4Ș÷⇹ĐŁřĐŁ<*žĐŁ⁻łŕ⇹Đ3Ș⇹÷Á↔áƇǰ

Prend une liste d'entiers et renvoie une chaîne de caractères.

Explication:

←ĐĐŁ₂⁻⦋⇹          Gets the ASCII code of the last character
ĐŁřĐŁ₂>*ž         Gets the list of products and removes the 0 from the end of the list
0`ŕ ...  ł        Loops (0 is there so that the length can be removed from the stack)
ĐĐŁ⁻⦋              Gets the last product
3ȘĐ4Ș3Ș4Ș÷        Divides by the last ASCII code obtained
⇹ĐŁřĐŁ<*ž         Removes the last element from the array
ĐŁ⁻ł              Gets the length of the array - 1 (if 0, then exit loop - the last entry still has to be processed)
ŕ⇹Đ3Ș⇹÷           Divides the remaining product by the last ASCII code obtained           
Á↔á               Converts to array of ints
Ƈǰ                Converts to string of ASCII characters

Essayez-le en ligne!

JavaScript (ES6), 80 octets

a=>String.fromCharCode(...eval(`for(a.splice(i=a.length/2);--i;a[i-1]-=a[i])a`))

f=

a=>String.fromCharCode(...eval(`for(a.splice(i=a.length/2);--i;a[i-1]-=a[i])a`))

console.log(
    f([173, 209, 216, 219, 198, 198, 225, 222, 208, 100, 7272, 10908, 11664, 11988, 9657, 9657, 12654, 12312, 10800, 0]),
    f([131, 133, 164, 195, 197, 99, 4290, 4422, 6499, 9506, 9702, 0])
)

Script VB - 74 71 octets

(J'ai réussi à réduire de 74 à 71 en utilisant While..Wend au lieu de Do..Loop)

L'entrée est dans un tableau a (), la sortie est dans la chaîne d

d="":p=0:n=(UBound(a)+1)/2:While n>0:n=n-1:t=a(n)-p:d=Chr(t)&d:p=t:Wend

Explication

d=""          '// initialize the output string
p=0          '// initialize the ansii of following char (working back from last char)
n=(Ubound(a)+1)/2 '// the index of the last summed pair + 1 (base 0)
While n>0    '// begin loop working back from last summed pair
n=n-1        '// move back 1 char
t=a(n)-p     '// calculate the ansii by subtracting the ansii of following char
d=Chr(t)&d   '// prepend the char to output
p=t          '// this char becomes the following char for next
Wend         '// repeat etc.

J'ai testé cela dans un fichier vbscript avec le code ci-dessus enveloppé comme une fonction:

dim s
Dim arr()
s = Split("173, 209, 216, 219, 198, 198, 225, 222, 208, 100, 7272, 10908, 11664, 11988, 9657, 9657, 12654, 12312, 10800, 0", ",")
ReDim arr(UBound(s))
Dim x 
For x = 0 To UBound(s)
    arr(x) = cint(s(x))
Next 

msgbox "=" & d(arr)



Private Function d(a())
d="":p=0:n=(UBound(a)+1)/2:While n>0:n=n-1:t=a(n)-p:d=Chr(t)&d:p=t:Wend
End Function

Nettoyer , 96 81 78 77 octets

zeroest le caractère nul.
Je pourrais enregistrer un autre octet si Clean n'était pas aussi pointilleux sur les valeurs nulles littérales dans le fichier source.

import StdEnv
f=init o foldr(\a t=[toChar a-t!!0:t])[zero]o takeWhile((>)245)

Essayez-le en ligne!

Perl 5 , 39 + 2 ( -ap) = 41 octets

$#F/=2;$\=chr($p=-$p+pop@F).$\while@F}{

Essayez-le en ligne!

C (gcc) , 90 89 octets

• Enregistré un octet grâce à plafondcat ; s+=(i%2?-1:1)*...<~> s-=~(i%2*-2).

D(C,l,j,s,i)int*C;{for(j=~0;++j<l/2;putchar(s))for(s=i=0;i+j<l/2;)s-=~(i%2*-2)*C[i+++j];}

Essayez-le en ligne!

ML standard (MLton) , 85 84 82 octets

fun!(x::r)=if x>244then[]else(fn z::s=>x-z::z::s|_=>[x])(!r);implode o map chr o!;

Essayez-le en ligne!

Non golfé:

fun g (x::r) =
   if   x > 244
   then []
   else case g r of
          z::s => x-z :: z :: s
        |  []  => [x]

val f = implode o map chr o g

Essayez-le en ligne!

Perl 6 ,  43 39  35 octets

{[~] [R,](produce *R-*,[R,] .[^*/2])».chr}

Essaye-le

{[~] [R,]([\[&(*R-*)]] [R,] .[^*/2])».chr}

Testez-le ^{_{(fait la même chose que ci-dessus)}}

{[~] [R,]([\R[&(*R-*)]] .[^*/2])».chr}

Essaye-le

{[R~] [\R[&(*R-*)]](.[^*/2])».chr}

Essaye-le

Explication:

{[R~] [\R[&(*R-*)]](.[^*/2])».chr}

{                                }      # block lambda with parameter `$_`

      [\R[&(*R-*)]](.[^*/2])            # turn sums back into ordinals (reversed)

                    .[^*/2]             # first half of `$_` (implicit method call)
            *R-*                        # lambda, reverse of *-*
         [&(    )]                      # use it as an infix operator
                                        # (same as R- except left associative)
        R                               # reverse arguments and associativity
                                        # (same as - except right associative)
      [\          ](       )            # produce values `[\+] 1,2,3` => `(1,3,6)`
                                        # uses associativity to determine direction
                                        # `[\**] 1,2,3` => `(3,8,1)`

                            ».chr       # call `.chr` method on all values
                                        # (possibly concurrently)

 [R~]                                   # concatenate in reverse
                                        # (shorter than `join '', reverse …`)

05AB1E , 9 octets

2ä¬Å«-}çJ

Essayez-le en ligne!

Explication

2ä        # Split input list in two (equal if possible) parts.
  ¬       # Push head(a).
   Å«-}   # Cumulative reduce the list by subtraction (from the right).
       ç  # Convert each integer in the list to its corresponding ASCII char.
        J # Join list together to string.

Japt, 12 octets

Il doit y avoir un moyen plus court pour obtenir la première moitié du tableau ...

¯UÊz)Ôån Ômd

Essayez-le

Python 2 , 70 octets

l,j,s=input(),0,'';n=len(l)/2
while n:n-=1;j=l[n]-j;s=chr(j)+s
print s

Essayez-le en ligne!