El problema:

¡Dos agentes secretos enemigos han ideado un maravilloso método de comunicación (para ti)!

Así es como funciona el proceso de cifrado:

1) Tome los equivalentes ascii de cada letra. (No se envían espacios, números o signos de puntuación)

2) Para cada letra en el mensaje, el equivalente ascii y la letra que sigue (si existe, si no existe, debe considerarse 0), se multiplican (este producto se almacena en una matriz / lista) y sumado (este número también se almacena en una lista diferente).

3) Las dos listas (de sumas y productos) se unen (la lista de sumas, luego la lista de múltiplos, en la misma matriz) y se transmiten.

¡Necesita escribir el programa más pequeño capaz de revertir este proceso y descifrar los mensajes enviados en este formato!

Ejemplo de pares de entrada y salida:

[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”

Este es el código de golf , por lo que gana la solución más pequeña en bytes.

Se permiten mensajes de error.

Su programa puede recibir una lista / matriz unidimensional o una cadena separada por comas, si así lo especifica en su envío. El valor predeterminado es una matriz / lista.

Casco , 7 6 bytes

mcĠ≠←½

Pruébalo en línea! De acuerdo con la documentación m, no debería ser necesario el inicio, pero parece que actualmente hay un error.

Editar: -1 byte gracias a Zgarb!

Explicación:

     ½ -- 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 bytes

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

La entrada es la cadena encriptada. Asume celdas de tamaño infinito y 0 en EOF.

Cómo funciona:

,[>>>+<[-<+>>-<]<[->+<],] 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 bytes

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

Pruébalo en línea!

Explicación

• fst.span(<245)toma todos los números del comienzo de la lista que son más pequeños que 245. Esos son solo los números de la parte de suma, porque la suma más grande posible es z + z = 122 + 122 = 244, y el producto más pequeño posible es A * A = 65 * 65 = 4225.
• scanr1(-)toma el último valor de la lista y lo usa como acumulador inicial. Luego, de atrás hacia adelante, cada elemento de la lista se resta por el acumulador actual, y el resultado se usa como el siguiente acumulador y se agrega a una lista.
• map toEnum reemplaza cada número en la lista con el carácter correspondiente para recrear la cadena.

Jalea , 9 bytes

œs2ḢUạ\ỌU

Pruébalo en línea! o Marque ambos casos de prueba.

Alternativa.

Explicación

œs2ḢUạ \ ỌU || Programa completo

œs2 || Divídase en dos partes, siendo la primera más larga si es necesario.
   Ḣ || Obtener la cabeza (primer elemento).
    U || Marcha atrás.
     ạ \ || Reducción acumulativa por sustracción.
       Ọ || Convierte de puntos de código a caracteres.
        U || Y revertir de nuevo.

Python 2 , 72 bytes

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

Pruébalo en línea!

Python 2 , 92 bytes

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

Pruébalo en línea!

Jalea , 11 bytes

œs2Ḣḅ-$ÐƤAỌ

Un enlace monádico que toma una lista de enteros y devuelve una lista de caracteres.

Pruébalo en línea!

¿Cómo?

œ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 bytes

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

Toma una lista de enteros y devuelve una cadena de caracteres.

Explicación:

←ĐĐŁ₂⁻⦋⇹          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

Pruébalo en línea!

JavaScript (ES6), 80 bytes

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])
)

VB Script - 74 71 bytes

(Logré reducir de 74 a 71 usando While..Wend en lugar de Do..Loop)

La entrada está en una matriz a (), la salida está en la cadena 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

Explicación

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.

Probé esto en un archivo vbscript con el código anterior envuelto como una función:

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

Limpio , 96 81 78 77 bytes

zeroes el caracter nulo.
Podría guardar otro byte si Clean no fuera tan exigente con los nulos literales en el archivo fuente.

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

Pruébalo en línea!

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

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

Pruébalo en línea!

C (gcc) , 90 89 bytes

• Guardado un byte gracias a ceilingcat ; 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];}

Pruébalo en línea!

ML estándar (MLton) , 85 84 82 bytes

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

Pruébalo en línea!

Sin 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

Pruébalo en línea!

Perl 6 ,  43 39  35 bytes

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

Pruébalo

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

Pruébelo ^{_{(hace lo mismo que arriba)}}

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

Pruébalo

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

Pruébalo

Explicación:

{[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 bytes

2ä¬Å«-}çJ

Pruébalo en línea!

Explicación

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 bytes

Tiene que haber una forma más corta de obtener la primera mitad de la matriz ...

¯UÊz)Ôån Ômd

Intentalo

Python 2 , 70 bytes

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

Pruébalo en línea!