Das Problem:

Zwei feindliche Geheimagenten haben eine wunderbare (für Sie) Kommunikationsmethode entwickelt!

So funktioniert der Verschlüsselungsprozess:

1) Nehmen Sie die Ascii-Äquivalente jedes Buchstabens. (Es werden keine Leerzeichen, Zahlen oder Satzzeichen gesendet.)

2) Für jeden Buchstaben in der Nachricht werden das ASCII-Äquivalent davon und der Buchstabe danach (falls vorhanden, falls nicht, sollte es als 0 betrachtet werden) multipliziert (dieses Produkt wird in einem Array / einer Liste gespeichert). und summiert (diese Nummer wird auch in einer anderen Liste gespeichert).

3) Die zwei Listen (von Summen und Produkten) werden zusammengefügt (die Summenliste, dann die Mehrfachliste, in demselben Array) und übertragen.

Sie müssen das kleinste Programm schreiben, das in der Lage ist, diesen Vorgang umzukehren und in diesem Format gesendete Nachrichten zu entschlüsseln!

Beispiel für Eingabe- und Ausgabepaare:

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

Das ist Code-Golf , also gewinnt die kleinste Lösung in Bytes.

Fehlermeldungen sind erlaubt.

Ihrem Programm kann entweder eine Liste / ein eindimensionales Array oder eine durch Kommas getrennte Zeichenfolge zugewiesen werden, wenn Sie dies in Ihrer Übermittlung angeben. Der Standardwert ist ein Array / eine Liste.

Schale , 7 6 Bytes

mcĠ≠←½

Probieren Sie es online! Laut Dokumentation sollte das Leading mnicht benötigt werden, aber es scheint aktuell einen Bug zu geben.

Edit: -1 Byte danke an Zgarb!

Erläuterung:

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

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

Die Eingabe ist die verschlüsselte Zeichenfolge. Nimmt unendlich große Zellen und 0 bei EOF an.

Wie es funktioniert:

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

Probieren Sie es online!

Erläuterung

• fst.span(<245)Nimmt alle Zahlen vom Anfang der Liste, die kleiner als 245 sind. Dies sind nur die Zahlen aus dem Summationsteil, da die größtmögliche Summe z + z = 122 + 122 = 244und das kleinstmögliche Produkt ist A * A = 65 * 65 = 4225.
• scanr1(-)Nimmt den letzten Wert der Liste und verwendet ihn als anfänglichen Akkumulator. Dann wird von hinten nach vorne jedes Element der Liste vom aktuellen Akkumulator subtrahiert, und das Ergebnis wird als nächster Akkumulator verwendet und einer Liste hinzugefügt.
• map toEnum Ersetzt jede Zahl in der Liste durch das entsprechende Zeichen, um die Zeichenfolge neu zu erstellen.

Gelee , 9 Bytes

œs2ḢUạ\ỌU

Probieren Sie es online! oder Überprüfen Sie beide Testfälle.

Alternative.

Erläuterung

œs2ḢUạ \ ỌU || Volles Programm.

œs2 || In zwei Teile teilen, wobei der erste bei Bedarf länger ist.
   Ḣ || Nimm den Kopf (erstes Element).
    U || Umkehren.
     ạ \ || Kumulativ durch Subtraktion reduzieren.
       Ọ || Konvertieren von Codepunkten in Zeichen.
        U || Und wieder rückwärts.

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

Probieren Sie es online!

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

Probieren Sie es online!

Gelee , 11 Bytes

œs2Ḣḅ-$ÐƤAỌ

Ein monadischer Link, der eine Liste von ganzen Zahlen erstellt und eine Liste von Zeichen zurückgibt.

Probieren Sie es online!

Wie?

œ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Ș⇹÷Á↔áƇǰ

Nimmt eine Liste von Ganzzahlen und gibt eine Zeichenfolge zurück.

Erläuterung:

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

Probieren Sie es online!

JavaScript (ES6), 80 Byte

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

(Ich habe es geschafft, von 74 auf 71 zu reduzieren, indem ich While..Wend anstelle von Do..Loop verwendete.)

Die Eingabe befindet sich in einem Array a (), die Ausgabe in der Zeichenfolge 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

Erläuterung

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.

Ich habe dies in einer vbscript-Datei mit dem obigen Code als Funktion getestet:

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

Sauber , 96 81 78 77 Bytes

zeroist das Nullzeichen.
Ich könnte ein weiteres Byte speichern, wenn Clean in Bezug auf Literal-Nullen in der Quelldatei nicht so pingelig wäre.

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

Probieren Sie es online!

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

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

Probieren Sie es online!

C (GCC) , 90 89 Bytes

• Dank ceilingcat ein Byte gespeichert ; 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];}

Probieren Sie es online!

Standard ML (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!;

Probieren Sie es online!

Ungolfed:

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

Probieren Sie es online!

Perl 6 ,  43 39  35 Bytes

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

Probier es aus

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

Teste es ^{_{(mache das selbe wie oben)}}

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

Probier es aus

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

Probier es aus

Erläuterung:

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

Probieren Sie es online!

Erläuterung

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

Es muss einen kürzeren Weg geben, um die erste Hälfte des Arrays zu erhalten ...

¯UÊz)Ôån Ômd

Versuch es

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

Probieren Sie es online!