Es gibt ein Echo in meinem Array ... Echo in meinem Array ... meinem Array

34

Hilfe! Ich scheine in einigen meiner Arrays ein störendes Echo zu haben, und ich würde es gerne loswerden. In diesem Fall wiederholt sich das ursprüngliche Array irgendwo in der Mitte, wodurch die Werte addiert werden.

Zum Beispiel [ 422, 375, 527, 375, 859, 451, 754, 451 ]enthält das Array ein Echo von sich selbst wie folgt:

[ 422, 375, 527, 375, 859, 451, 754, 451 ] <-- array with echo (input)

[ 422, 375, 105,   0, 754, 451           ] <-- original array (output)
[           422, 375, 105,   0, 754, 451 ] <-- echo of original array

Beispiel 2:

[ 321, 526, 1072, 899, 6563, 798, 7038, 3302, 3032, 3478, 1806, 601 ] <-- input

[ 321, 526,  751, 373, 5812, 425, 1226, 2877, 1806,  601            ] <-- output
[            321, 526,  751, 373, 5812,  425, 1226, 2877, 1806, 601 ]

Es ist auch möglich, dass das Array kein Echo enthält. In diesem Fall wird das ursprüngliche Array zurückgegeben:

Beispiel 3:

[ 623, 533, 494, 382 ] <-- input
[ 623, 533, 494, 382 ] <-- output

Herausforderung:

Entfernen Sie ein Array, das möglicherweise ein Echo enthält, und geben Sie das Array ohne Echo zurück.

Eingang:

  • Ein Array, eine Liste, eine durch Trennzeichen getrennte Zeichenfolge, Lochkarten oder ein für Ihre Plattform geeignetes Äquivalent mit drei oder mehr Ganzzahlen im Bereich von mit mindestens einem Element .0n<10000>0
  • Das Echo kann nicht am ersten oder nach dem letzten Element beginnen.
  • Das Echo tritt innerhalb des Eingangs nur einmal oder gar nicht auf.

Ausgabe:

  • Ein Array, eine Liste usw. von Ganzzahlen , wobei das Echo entfernt wurde.0n<10000
  • Wenn kein Echo vorhanden ist, geben Sie das ursprüngliche Array zurück.

Regeln und Wertung:

Testfälle:

Mit Echo:

[ 422, 375, 527, 375, 859, 451, 754, 451 ]
[ 422, 375, 105, 0, 754, 451 ]

[ 321, 526, 1072, 899, 6563, 798, 7038, 3302, 3032, 3478, 1806, 601 ]
[ 321, 526, 751, 373, 5812, 425, 1226, 2877, 1806, 601 ]

[ 4330, 3748, 363, 135, 2758, 3299, 1674, 1336, 4834, 2486, 4087, 1099, 4098, 4942, 2159, 460, 4400, 4106, 1216, 3257, 1638, 2848, 3616, 3554, 1605, 490, 1308, 2773, 3322, 3284, 4037, 7109, 4171, 5349, 2675, 3056, 4702, 4229, 1726, 5423, 6039, 8076, 6047, 7088, 9437, 4894, 1946, 7501, 5331, 3625, 5810, 6289, 2858, 6610, 4063, 5565, 2200, 3493, 4573, 4906, 3585, 4147, 3748, 3488, 5625, 6173, 3842, 5671, 2555, 390, 589, 3553, 3989, 4948, 2990, 4495, 2735, 1486, 3101, 1225, 2409, 2553, 4651, 10, 2994, 509, 3960, 1710, 2185, 1800, 1584, 301, 110, 969, 3065, 639, 3633, 3544, 4268 ]
[ 4330, 3748, 363, 135, 2758, 3299, 1674, 1336, 4834, 2486, 4087, 1099, 4098, 4942, 2159, 460, 4400, 4106, 1216, 3257, 1638, 2848, 3616, 3554, 1605, 490, 1308, 2773, 3322, 3284, 4037, 2779, 423, 4986, 2540, 298, 1403, 2555, 390, 589, 3553, 3989, 4948, 2990, 4495, 2735, 1486, 3101, 1225, 2409, 2553, 4651, 10, 2994, 509, 3960, 1710, 2185, 1800, 1584, 301, 110, 969, 3065, 639, 3633, 3544, 4268 ]

[ 24, 12, 52, 125, 154, 3, 567, 198, 49, 382, 53, 911, 166, 18, 635, 213, 113, 718, 56, 811, 67, 94, 80, 241, 343, 548, 68, 481, 96, 79, 12, 226, 255, 200, 13, 456, 41 ]
[ 24, 12, 52, 125, 154, 3, 567, 198, 25, 370, 1, 786, 12, 15, 68, 15, 88, 348, 55, 25, 55, 79, 12, 226, 255, 200, 13, 456, 41 ]

[ 1, 3, 2 ]
[ 1, 2 ]

[ 0, 1, 3, 2, 0 ]
[ 0, 1, 2, 0 ]

Ohne Echo:

[ 623, 533, 494, 382 ]
[ 623, 533, 494, 382 ]

[ 1141, 1198, 3106, 538, 3442, 4597, 4380, 3653, 1370, 3987, 1964, 4615, 1844, 5035, 2463, 6345, 4964, 4111, 5192, 8555, 5331, 3331, 4875, 6586, 5728, 4532, 5972, 2305, 3491, 6317, 2256, 2415, 5788, 4873, 6480, 2080, 5319, 4551, 6527, 5267, 4315, 2178, 2615, 5735, 5950, 6220, 7114, 6259, 5000, 4183, 6822, 6927, 7150, 8003, 5603, 3154, 8231, 5005, 5743, 6779, 4530, 4029, 5336, 6105, 4777, 6183, 6838, 5725, 6819, 8584, 3142, 3840, 3291, 4284, 2933, 4859, 2906, 5176, 2853, 2110, 2048, 4389, 4501, 2267, 2704, 431, 1495, 2712, 3008, 187, 3487, 630 ]
[ 1141, 1198, 3106, 538, 3442, 4597, 4380, 3653, 1370, 3987, 1964, 4615, 1844, 5035, 2463, 6345, 4964, 4111, 5192, 8555, 5331, 3331, 4875, 6586, 5728, 4532, 5972, 2305, 3491, 6317, 2256, 2415, 5788, 4873, 6480, 2080, 5319, 4551, 6527, 5267, 4315, 2178, 2615, 5735, 5950, 6220, 7114, 6259, 5000, 4183, 6822, 6927, 7150, 8003, 5603, 3154, 8231, 5005, 5743, 6779, 4530, 4029, 5336, 6105, 4777, 6183, 6838, 5725, 6819, 8584, 3142, 3840, 3291, 4284, 2933, 4859, 2906, 5176, 2853, 2110, 2048, 4389, 4501, 2267, 2704, 431, 1495, 2712, 3008, 187, 3487, 630 ]

[ 4791, 1647, 480, 3994, 1507, 99, 61, 3245, 2932, 8358, 6618, 1083, 5391, 3498, 4865, 1441, 3729, 5322, 5371, 6271, 2392, 1649, 5553, 9126, 3945, 2179, 3672, 2201, 4433, 5473, 4924, 6585, 6407, 3862, 6505, 1530, 5293, 4792, 6419, 6739, 3258, 3839, 3891, 7599, 2576, 5969, 5659, 6077, 5189, 1325, 4490, 5694, 6567, 6367, 5724, 5756, 6450, 5863, 4360, 2697, 3100, 3779, 4040, 4653, 1755, 3109, 2741, 3269 ]
[ 4791, 1647, 480, 3994, 1507, 99, 61, 3245, 2932, 8358, 6618, 1083, 5391, 3498, 4865, 1441, 3729, 5322, 5371, 6271, 2392, 1649, 5553, 9126, 3945, 2179, 3672, 2201, 4433, 5473, 4924, 6585, 6407, 3862, 6505, 1530, 5293, 4792, 6419, 6739, 3258, 3839, 3891, 7599, 2576, 5969, 5659, 6077, 5189, 1325, 4490, 5694, 6567, 6367, 5724, 5756, 6450, 5863, 4360, 2697, 3100, 3779, 4040, 4653, 1755, 3109, 2741, 3269 ]

[ 235, 121, 52, 1249, 154, 26, 5672, 1975, 482, 3817, 532, 9104, 1661, 171, 6347, 2124, 1122, 7175, 558, 8101, 667, 934, 798, 2404, 3424, 5479, 672, 4808, 956, 789, 123, 2255, 2549, 200, 126, 4562, 41 ]
[ 235, 121, 52, 1249, 154, 26, 5672, 1975, 482, 3817, 532, 9104, 1661, 171, 6347, 2124, 1122, 7175, 558, 8101, 667, 934, 798, 2404, 3424, 5479, 672, 4808, 956, 789, 123, 2255, 2549, 200, 126, 4562, 41 ]

[ 1, 1, 1, 1, 1 ]
[ 1, 1, 1, 1, 1 ]
640 KB
quelle
3
Was ist, wenn es mehrere mögliche Ausgaben gibt? Input: [1, 2, 2, 2, 1]; Ausgabe: [1, 1, 1, 1]vs.[1, 2, 1]
tsh
3
Wie hoch ist die erwartete Ausgabe für [1, 2, 3, 1, 2, 3], [1, 2, 3, 0, 1, 2, 3], [0, 1, 3, 2, 0]? Aktuelle Antworten stimmen nicht für alle diese Eingaben überein.
Dienstag,
@tsh Beides ( [1, 1, 1, 1]vs. [1, 2, 1]) ist akzeptabel. Ich hatte ursprünglich eine Regel zur Auswahl, nahm sie jedoch im Sandkasten ab, da sie nur für eine kleine Anzahl von Randfällen zu gelten schien.
11.
@tsh, [0, 1, 3, 2, 0]sollte sein [0, 1, 2, 0]- ich habe zu den Testfällen hinzugefügt. Eine erwartete Antwort auf die anderen beiden könnte sein, [1, 2, 3]obwohl ich diese gültigen Testfälle nicht berücksichtigen würde, da sie den Regeln entsprechen the original array repeats itself somewhere in the middle.
11.
1
@ Nimi Gute. Ich würde sagen, es ist mehrdeutig, ob [0,0,0](oder ein beliebig großes 0Array von allen ) ein Echo von irgendetwas darstellt oder ob [0,0,0](kein Echo) auch für diesen Sonderfall eine gültige Antwort wäre, da es einfach nicht genug Informationen gibt, um zu bestimmen, welches es ist. Ich werde die Regeln aktualisieren, um zu verhindern, dass dies eine gültige Eingabe ist, da dadurch keine vorhandenen Antworten ungültig werden oder geändert werden.
11.

Antworten:

8

MATL , 16 Bytes

t"GX@WQB&Y-~?w]x

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Polynomdivision für den Sieg!

t      % Implicit input. Duplicate
"      % For each (do the following as many times as input length)
  G    %   Push input again. This will be the output if no solution exists
  X@   %   Push current iteration index, k
  WQB  %   2 raised to that, add 1, convert to binary. Gives [1 0 ... 0 1] (k-1 zeros)
  &Y-  %   Two-output polynomial division (deconvolution). Gives quotient and remainder
  ~    %   Logical negate: transforms zeros into 1, nonzeros into 0
  ?    %   If all values are nonzero (i.e. if remainder was all zeros): solution found
    w  %      Swap. This moves the copy of the input to top (to be deleted)
  ]    %   End
  x    %   Delete. This deletes the quotient if it was not a solution, or else deletes
       %   the copy of the input
       % End (implicit). Since it is guaranteed that at most one solution exists, at this
       % point the stack contains either the solution or the input
       % Implicit display
Luis Mendo
quelle
Keine Abnehmer der "Eso" - oder "historischen" Sprachprämie, also Prämie wird immer beliebter!
4.
1
@ 640KB Ich wusste nicht, dass es für diese Herausforderung ein Kopfgeld gibt! Vielen Dank!
Luis Mendo
7

Haskell , 167 Bytes

Zunächst ist zu beachten, dass bei einem vorhandenen Echo das Eingabearray eine Faltung eines anderen Arrays mit einem Array des Formulars ist [1,1],[1,0,1],[1,0,0,1],....

Dies bedeutet, dass wir dies nur für alle diese Arrays überprüfen müssen. Diskrete Faltung / Entfaltung ist jedoch dasselbe wie polynomielle Multiplikation / lange Division, so dass dies nur eine Implementierung unter Verwendung von Polynomen ist, wobei jedes Mal, wenn möglich, der Quotient zurückgegeben wird.

Ein Trick, der das Ganze ein wenig verkürzte, war, zusätzlich zu den obigen Arrays auch nach [1]einem Basisfall zu suchen, denn wenn kein anderes Array funktioniert, funktioniert die Dekonvolution mit [1]und gibt das ursprüngliche Polynom zurück.

import Math.Polynomial
import Data.Ratio
p=poly LE
c z=last[polyCoeffs LE q|k<-zipWith const[p(take k(1:repeat 0)++[1])|k<-[0..]]z,(q,r)<-[quotRemPoly(p z)k],r==zero] 

Probieren Sie es online!

fehlerhaft
quelle
Guter Trick mit dem Base Case! Ich habe versucht, das in meine Antwort aufzunehmen, aber ich könnte den Code verkürzen
Luis Mendo
4

JavaScript , 211 171 145 Bytes

s=>{for(n=x=0,y=s.length;++x<y/2&!n;)for(n=s.slice(i=0,x);i+x<y-x&&n;)n=(n[i+x]=s[i+x]-n[i++])<0?0:n;return n&&n.slice(1-x)+''==s.slice(1-x)?n:s}

Probieren Sie es online aus

40 Bytes von Kevin Cruijssen

Weitere 26 Bytes von Arnauld

Meine erste Code-Golf-Antwort macht potenzielle Offsets ungültig und gibt entweder das ursprüngliche oder das neue Array zurück, je nachdem, was es findet. Wenn jemand weiß, wie man es kürzer macht, lass es mich wissen, es scheint ein lustiges Spiel zu sein.

Levi Faid
quelle
1
Ich kenne mich mit JavaScript nicht so gut aus, aber mit einigen grundlegenden Funktionen (z. B. Entfernen unnötiger Klammern, Ändern der Platzierungen von ++, Ändern &&von &in der ersten Überprüfung, Ändern von beiden .toString()in +''usw.) habe ich Ihren Code auf 181 Byte reduziert . Wenn Sie sie noch nicht gesehen haben, sind Tipps zum Golfen in JavaScript und Tipps zum Golfen in allen Sprachen möglicherweise interessant. :)
Kevin Cruijssen
1
Oh, vergessen ( function q(s)kann sein s=>): 171 Bytes . Genieße deinen Aufenthalt! :)
Kevin Cruijssen
Danke dafür, ich werde eine Lektüre haben. Ich bin nicht sehr geschickt mit Javascript, aber ich musste in letzter Zeit ein wenig nachhelfen und dachte, dass dies eine gute Möglichkeit sein könnte, meine Ausfallzeit etwas
Levi Faid
1
Golfen Sie noch etwas (ohne alle Tests, so dass es als direkte URL in diesen Kommentar passt)
Arnauld
1
Willkommen bei Code Golf SE! Wir wünschen Ihnen viel Spaß beim Golfen!
Giuseppe
3

Haskell, 112 111 110 Bytes

l=length
(!)=splitAt
f a=last$a:[x|i<-[1..l a],let (h,t)=i!a;o=h++zipWith(-)t o;(x,y)=l t!o,all(>=0)o,sum y<1]

Probieren Sie es online!

f a=                
      i<-[1..l a]                -- for all indices 'i' of the input array 'a'
      (h,t)=i!a                  -- split 'a' at 'i' into 'h' and 't'
                                 -- e.g. a: [1,2,3,4], i: 1 -> h: [1], t:[2,3,4] 
      o=                         -- calculate the original array by
        h++                      --   prepended 'h' to
        zipWith(-)t o            --   the (element-wise) difference of
                                 --   't' and itself
      (x,y)=l t!o                -- split 'o' at position <length of t>
                                 --
                                 -- example:
                                 --      a: [0,1,3,2,0]
                                 --      h: [0]
                                 --      t: [1,3,2,0]
                                 --   now
                                 --      o: [0,1,2,0,0]
                                 --      x: [0,1,2,0]
                                 --      y: [0]
                                 --
    ,                            -- 'o' is valid, if
     all(>=0)o                   --   all elements of 'o' are not negative
    ,sum y<1                     --   and 'y' is all zeros
  [x|         ]                  -- keep 'x' (a valid echo array) if 'o' is valid

 last $ a :[  ]                  -- if there's no echo, the list of 'x's is empty
                                 -- and 'a' is picked, else the last of the 'x's 
nimi
quelle
3

Wolfram Language (Mathematica) , 131 129 120 119 102 98 97 96 95 Bytes

(w=#;Do[(w=v/.#)&/@Thread[#==PadLeft[v=Array[x,L-d],L]+v~PadRight~L]~Solve~v,{d,L=Tr[1^#]}];w)&

Probieren Sie es online!

−1 byte dank attinat : wir können schreiben L=Tr[1^#]anstatt L=Length@#wenn das argument eine liste von zahlen ist.

Codeerklärung : Durchlaufen Sie die Schrumpfung d(Differenz zwischen Eingabe- und Ausgabelänge). Erstellen Sie für jede Länge der Ausgabeliste eine Liste mit Unbekannten, v={x[1],x[2],...,x[L-d]}fügen Sie sie sich mit Links- und Rechtspolstern zu length L( PadLeft[v,L]+PadRight[v,L]) hinzu, setzen Sie diese Summe auf die Eingabeliste und lösen Sie nach Unbekannten auf x[1]...x[L-d]. Wählen Sie die kürzeste Lösung aus, die zuletzt generiert wurde: Überschreiben Sie die Variable einfach wjedes Mal, wenn eine Lösung gefunden wird.

Ungolf-Version:

F = Function[A,                                  (* A is the input list *)
  Module[{L = Length[A],                         (* length of A *)
          v,                                     (* list of unknowns *)
          x,                                     (* unknowns in v *)
          w = A},                                (* variable for solution, defaults to A *)
    Do[                                          (* loop over shrinkage: d = Length[A]-Length[output] *)
      v = Array[x, L - d];                       (* list of unknowns to be determined *)
      (w = v /. #) & /@                          (* overwrite w with every... *) 
        Solve[                                   (* ...solution of... *)
          Thread[PadLeft[v,L]+PadRight[v,L]==A], (* ...v added to itself, left-padded and right-padded, equals A *)
          v],                                    (* solve for elements of v *)
    {d, L}];                                     (* loop for shrinkage from 1 to L (the last case d=L is trivial) *)
    w]];                                         (* return the last solution found *)
römisch
quelle
-1 mit Tr[1^#]stattLength@#
attinat
2

Jelly , 25 24 Bytes

ðsạ\FḣL_¥,+¥Ż⁹¡$µⱮLṪ⁼¥Ƈȯ

Probieren Sie es online!

Ein monadischer Link, der eine Liste von Ganzzahlen aufnimmt und zurückgibt. Technisch gesehen sind die erfolgreichen Ergebnisse in zwei weiteren Listen verschachtelt, aber bei Ausführung als vollständiges Programm ignoriert die implizite Ausgabe an stdout die redundanten Listen.

Nick Kennedy
quelle
2

Python 2 , 113 123 128 127 123 122 Bytes

def f(a,i=1):
 e=a[:i]
 for v in a[i:-i]:e+=v-e[-i],
 return i<=len(a)/2and(min(e)>=0<e[-i:]==a[-i:]and e or f(a,i+1))or a

Probieren Sie es online!

1 Byte Danke an TFeld ; und 1 Byte Danke an Sebastian Kreft .

Bei jedem Aufruf von fkonstruieren wir ein potentielles Echo der Länge len(a)-i. Der erste Teil besteht nur aus den ersten iBytes von a; Der Rest wird so berechnet, dass die "Echosumme" für den "überlappenden" Abschnitt der Echosumme korrekt ist (dh die Echosumme ist bis zu korrekt a[:-i]).

Dann ergibt der sehr knappe Vergleich ohne Golf:

if i>=len(a)/2+1:
    return a # because it can't be that short, so there is no echo
else:
    if min(e)>=0                       # all elements are non-negative
                 and e[-i:]==a[-i:]:   # and the tails are the same
        return e                       # it's a match!
    else:
        return f(a,i+1)                # recurse
Chas Brown
quelle
e+=[v-e[-i]]kann seine+=v-e[-i],
TFeld
Sie können einen weiteren Charakter rasieren, indem Sie dies tuni<=len(a)/2
Sebastian Kreft
2

Wolfram-Sprache (Mathematica) , 93 Bytes

(b=#;Do[a=#;Do[a[[i+j]]-=a[[j]],{j,2k}];a/.{__?(#>=0&),0}:>(b=a~Drop~-i),{i,k=Tr[1^#]/2}];b)&

Probieren Sie es online!

Gibt das kürzeste in der Liste vorhandene Echo zurück.

attinat
quelle
Es sieht aus wie das nicht klappt auf {1,1,1}und auf {1,0,1}.
Roman
@ Roman gibt es in keinem dieser Fälle ein Echo?
18.
Da {1,1,1}es kein Echo gibt, müssen Sie das ursprüngliche Array zurückgeben. Denn {1,0,1}ich würde sagen, das Echo ist, {1}aber zugeben, es ist ein bisschen unklar, wie die Regeln lauten.
Roman
Ah richtig. Danke für den Fang!
19.
2

PHP , 124 Bytes

function($a){while(!$z&&++$y<$c=count($b=$a))for($x=0;$x<$c&$z=0<=$b[$x+$y]-=$b[$x++];);return array_slice($b,0,$c-$y)?:$a;}

Probieren Sie es online!

Erläuterung:

>0

function( $a ) {
  // iterate through all possible offsets of echo
  while( ! $b && ++$y < $c = count( $b = $a ) ) {
    // create a copy of input array, iterate through all elements
    for( $x = 0; $b && $x < $c; ) {
      // if difference between the elements in the offset copy of 
      // the array is positive, subtract the value in the input array
      // from the offset array in the same column
      if ( ( $b[ $x+$y ] -= $b[ $x++ ] ) < 0 ) {
        // result is not valid, erase array and break out of loop
        $b = 0;
      }
    }
  }
  // truncate output array to correct size. if still contains values, 
  // it is a valid result. otherwise return the original array
  return array_slice( $b, 0, $c-$y ) ?: $a;
}
640 KB
quelle
2

Python 3 , 111 Bytes

def f(r,l=1):o=r[:l];o+=(v-o[-l]for v in r[l:]);return l<len(r)and(min(o)<any(o[-l:])and f(r,l+1)or o[:-l])or r

Probieren Sie es online!

Die Lösung basiert auf Ideen von @Chas Brown, wie der rekursiven Struktur und dem Aufbau des Output-Arrays. In der Zwischenzeit werden auch einige Änderungen an den Bewertungskriterien vorgenommen und die for-Schleife in einen Generatorausdruck eingefügt, um eine einzeilige Lösung zu ermöglichen. Die ungolfed Version wird im Folgenden gezeigt. Hier wird das Array outbis zum Ende des Eingabe-Arrays berechnet und dann überprüft, ob die letzten lElemente alle Null sind. In diesem Fall werden die ersten len(arr)-lElemente als Antwort zurückgegeben, wenn sie alle nicht negativ sind.

Ungolfed, nicht rekursive Version

def remove_echo(arr):
    l = 1
    while l < len(arr):
        out = arr[:l]
        out += (v - out[-l] for v in arr[l:])
        if min(out) >= 0 and out[-l:] == [0] * l:
            return out[:-l]
        l += 1
    return arr

Probieren Sie es online!

Joel
quelle
1
@ 640KB Ich habe geprüft, ob die zurückgegebene Antwort mit dem erwarteten Ergebnis in meinem Code übereinstimmt, und habe nur dann eine Nachricht gedruckt, wenn keine Übereinstimmung vorliegt. Keine Ausgabe bedeutet also, dass alles korrekt ist. Ich gebe zu, dass dies auf den ersten Blick verwirrend sein kann und aktualisiere es später, um "Richtig" auf einem Streichholz auszudrucken.
Joel
1
@ 640KB Aktualisiert.
Joel
1

Holzkohle , 62 Bytes

≔⁰ζF⊘Lθ«≔E⊕ι⁰ηFLθ§≔ηκ⁻§θκ§ηκ¿⬤η¬κ≔⊕ιζ»F⁻Lθζ⊞υ⁻§θι∧ζ∧¬‹ιζ§υ±ζIυ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔⁰ζ

Angenommen, es gibt kein Echo.

F⊘Lθ«

Probieren Sie alle möglichen Echostartpunkte aus. Hinweis: Möglicherweise habe ich die Frage falsch verstanden und versuche nicht genügend Echogrößen. In diesem Fall wäre das nicht erforderlich.

≔E⊕ι⁰η

Beginnen Sie mit einem Array von Nullen, die dieselbe Größe haben wie der Startpunkt des Echos.

FLθ§≔ηκ⁻§θκ§ηκ

Subtrahieren Sie für jedes Element im ursprünglichen Array das Element im Echo-Array zyklisch davon. Jedes Element im Echo-Array bildet somit die alternierende Summe der voneinander entfernten Elemente.

¿⬤η¬κ≔⊕ιζ»

Wenn alle alternierenden Summen Null sind, speichern Sie dies als möglichen Startpunkt. (Wenn es also mehr als eine Möglichkeit gibt, wird der größtmögliche Startpunkt verwendet.)

F⁻Lθζ⊞υ⁻§θι∧ζ∧¬‹ιζ§υ±ζ

Bauen Sie das Echo-Array auf, indem Sie Elemente nach dem Startpunkt vom entsprechenden zuvor berechneten Element subtrahieren.

Iυ

Für implizite Ausgabe in separate Zeilen in Zeichenfolge umwandeln.

Neil
quelle