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 .$0\leq n\lt10000$$\gt 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.$0\leq n\lt10000$
• Wenn kein Echo vorhanden ist, geben Sie das ursprüngliche Array zurück.

Regeln und Wertung:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes für jede Sprache.
• Es gelten Standardregeln und Standard-E / A-Regeln .
• Lücken verboten (natürlich).
• Bitte geben Sie einen Link mit einem Test für Ihren Code an ( TIO.run usw.).
• Eine klare Erklärung für Ihre Antwort wird dringend empfohlen.

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 ]

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

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!

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.

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 

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

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.

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

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.

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:

$\gt 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;
}

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!

Holzkohle , 62 Bytes

≔⁰ζＦ⊘Ｌθ«≔Ｅ⊕ι⁰ηＦＬθ§≔ηκ⁻§θκ§ηκ¿⬤η¬κ≔⊕ιζ»Ｆ⁻Ｌθζ⊞υ⁻§θι∧ζ∧¬‹ιζ§υ±ζＩυ

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

≔⁰ζ

Angenommen, es gibt kein Echo.

Ｆ⊘Ｌθ«

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.

≔Ｅ⊕ι⁰η

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

ＦＬθ§≔ηκ⁻§θκ§ηκ

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

Ｆ⁻Ｌθζ⊞υ⁻§θι∧ζ∧¬‹ιζ§υ±ζ

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

Ｉυ

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