Echo w mojej tablicy… echo w mojej tablicy… moja tablica

34

Wsparcie! Wydaje mi się, że mam irytujące echo w niektórych moich tablicach i chciałbym się go pozbyć. Kiedy to nastąpi, oryginalna tablica powtarza się gdzieś pośrodku, powodując dodawanie wartości.

Na przykład tablica [ 422, 375, 527, 375, 859, 451, 754, 451 ]zawiera swoje echo:

[ 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

Przykład 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 ]

Możliwe jest również, że w tablicy nie ma echa, w którym to przypadku zwraca oryginalną tablicę:

Przykład 3:

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

Wyzwanie:

Biorąc pod uwagę tablicę, która może zawierać echo, usuń ją i zwróć tablicę bez echa.

Wkład:

  • Tablica, lista, łańcuch rozdzielany, karty perforowane lub odpowiednik odpowiedni dla platformy, zawierający trzy lub więcej liczb całkowitych z zakresu z co najmniej jednym elementem .0n<10000>0
  • Echo nie może rozpocząć się od pierwszego ani po ostatnim elemencie.
  • Echo pojawi się tylko raz lub w ogóle na wejściu.

Wydajność:

  • Tablica, lista itp. Liczb całkowitych 0n<10000 , z usuniętym echem.
  • Jeśli nie ma echa, zwróć oryginalną tablicę.

Zasady i punktacja:

Przypadki testowe:

Z echem:

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

Bez echa:

[ 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
źródło
3
Co jeśli istnieje wiele możliwych wyników? Wejście: [1, 2, 2, 2, 1]; Wyjście: [1, 1, 1, 1]vs.[1, 2, 1]
tsh
3
Jaki jest oczekiwany wyjście [1, 2, 3, 1, 2, 3], [1, 2, 3, 0, 1, 2, 3], [0, 1, 3, 2, 0]? Aktualne odpowiedzi nie zgadzają się co do wszystkich tych danych wejściowych.
tsh
@tsh Każde z tych ( [1, 1, 1, 1]vs. [1, 2, 1]) jest dopuszczalne. Początkowo miałem regułę dotyczącą wyboru, ale zdjąłem ją w piaskownicy, ponieważ zdawało się, że dotyczy ona tylko niewielkiej liczby skrzynek.
640 KB
@tsh, [0, 1, 3, 2, 0]powinno być [0, 1, 2, 0]- dodałem do przypadków testowych. Oczekiwaną odpowiedzią na pozostałe dwa pytania może być [1, 2, 3]to, że nie wziąłbym pod uwagę tych ważnych przypadków testowych, ponieważ zgodnie z regułami the original array repeats itself somewhere in the middle.
640 KB
1
@nimi Dobry. Powiedziałbym, że nie jest jednoznaczne, czy [0,0,0](lub jakakolwiek 0tablica all-all ) reprezentuje echo czegokolwiek, czy też [0,0,0](brak echa) również byłaby poprawną odpowiedzią na ten szczególny przypadek, ponieważ po prostu nie ma wystarczających informacji, aby ustalić, który to jest. Zaktualizuję reguły, aby ograniczyć to do poprawnego wprowadzania, ponieważ nie unieważni to ani nie zmieni żadnych istniejących odpowiedzi.
640 KB

Odpowiedzi:

8

MATL , 16 bajtów

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

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

Wielomianowy podział na zwycięstwo!

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
źródło
Żadnych chętnych na nagrodę za „eso” lub „historyczną” nagrodę za to ... więc nagroda zyskuje na popularności!
640 KB
1
@ 640KB Nie wiedziałem, że nagrodą za to wyzwanie! Dziękuję Ci!
Luis Mendo
7

Haskell , 167 bajtów

Po pierwsze, ważne jest, aby zauważyć, że jeśli występuje echo, to tablica wejściowa jest splotem innej tablicy z pewną tablicą formy [1,1],[1,0,1],[1,0,0,1],....

Oznacza to, że musimy to sprawdzić dla wszystkich tych tablic. Ale dyskretna splot / dekonwolucja jest tym samym, co wielomianowe mnożenie / dzielenie długie, więc jest to tylko implementacja wykorzystująca wielomiany, za każdym razem zwracając iloraz, jeśli to możliwe.

Jedną sztuczką, która nieco skróciła to wszystko, było oprócz powyższych tablic sprawdzenie również [1]jako przypadek podstawowy, ponieważ jeśli żadna inna tablica nie działa, dekonwolucja z [1]zadziała i zwróci oryginalny wielomian.

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] 

Wypróbuj online!

wada
źródło
Dobra sztuczka z podstawą! Próbowałem włączyć to do mojej odpowiedzi, ale mogłem skrócić kod
Luis Mendo
4

JavaScript , 211 171 145 bajtów

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}

Wypróbuj online

40 bajtów od Kevina Cruijssena

Kolejne 26 bajtów z Arnauld

Moja pierwsza odpowiedź na kod golfowy unieważnia potencjalne przesunięcia i zwraca oryginalną lub nową tablicę w zależności od tego, co znajdzie. Jeśli ktoś wie, jak go skrócić, proszę daj mi znać, wygląda na fajną grę.

Levi Faid
źródło
1
Nie jestem zbyt wykwalifikowanych z JavaScript, ale z pewnymi podstawowymi Golfy (czyli usunięcie zbędnych nawiasów, zmiana miejsca docelowe Spośród ++zmieniając &&się &w pierwszej kontroli, zmieniając zarówno .toString()do +'', itd.) Mam kod w dół do 181 bajtów . Jeśli jeszcze ich nie widziałeś, pomocne mogą być Wskazówki dotyczące gry w JavaScript i Wskazówki dotyczące gry we wszystkie języki . :)
Kevin Cruijssen
1
Och, zapomniałem jednego ( function q(s)może być s=>): 171 bajtów . Miłego pobytu! :)
Kevin Cruijssen
Dzięki za to, przeczytam. Nie jestem zbyt przydatny w javascript, ale ostatnio musiałem trochę popracować i pomyślałem, że to może być dobry sposób na odrobinę czasu w moim przestoju
Levi Faid
1
Grał w golfa jeszcze trochę (bez wszystkich testów, aby pasował jako bezpośredni adres URL w tym komentarzu)
Arnauld
1
Witamy w Code Golf SE! Mamy nadzieję, że spodoba ci się tutaj gra w golfa!
Giuseppe
3

Haskell, 112 111 110 bajtów

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]

Wypróbuj 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
źródło
3

Wolfram Language (Mathematica) , 131 129 120 119 102 98 97 96 95 bajtów

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

Wypróbuj online!

-1 bajt dzięki attinat : możemy pisać L=Tr[1^#]zamiast, L=Length@#gdy argumentem jest lista liczb.

Objaśnienie kodu: Iteruj przez skurcz d(różnicę między długością wejściową i wyjściową). Dla każdej długości listy wyjściowej utwórz listę niewiadomych v={x[1],x[2],...,x[L-d]}i dodaj do niej lewy i prawy dopełniony do length L( PadLeft[v,L]+PadRight[v,L]), a następnie ustaw tę sumę na liście wejściowej i rozwiąż dla niewiadomych x[1]...x[L-d]. Wybierz najkrótsze rozwiązanie, które jest ostatnim generowanym: po prostu nadpisuj zmienną za wkażdym razem, gdy znajdziesz rozwiązanie.

Wersja bez gry w golfa:

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 *)
rzymski
źródło
-1 z Tr[1^#]zamiastLength@#
attinat
2

Galaretka , 25 24 bajtów

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

Wypróbuj online!

Monadyczny link, który pobiera i zwraca listę liczb całkowitych. Technicznie udane wyniki są zagnieżdżone na dwóch kolejnych listach, ale po uruchomieniu jako pełny program niejawne dane wyjściowe dla standardowego wyjścia ignorują nadmiarowe listy.

Nick Kennedy
źródło
2

Python 2 , 113 123 128 127 123 122 bajtów

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

Wypróbuj online!

1 bajt thx na TFeld ; i 1 bajt dzięki za Sebastian Kreft .

Przy każdym wywołaniu do fkonstruujemy potencjalne echo długości len(a)-i. Pierwsza część to tylko pierwsze ibajty; reszta jest obliczana w taki sposób, że „suma echa” będzie poprawna dla „pokrywającej się” części sumy echa (tj. suma echa jest poprawna do a[:-i]).

Następnie bardzo skrócone porównanie, bez gry w golfa, daje:

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
źródło
e+=[v-e[-i]]może byće+=v-e[-i],
TFeld
możesz ogolić jeszcze jedną postaći<=len(a)/2
Sebastian Kreft
2

Wolfram Language (Mathematica) , 93 bajty

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

Wypróbuj online!

Zwraca najkrótsze echo obecne na liście.

attinat
źródło
Wygląda to tak nie działa na {1,1,1}i na {1,0,1}.
Rzym.
@Roman nie ma echa w żadnym z tych przypadków?
attinat
Ponieważ {1,1,1}nie ma echa, więc musisz zwrócić oryginalną tablicę. Dla {1,0,1}Powiedziałbym, że echo jest {1}jednak przyznać, że to trochę niejasne, jakie są zasady.
Roman
Ah, tak. Dzięki za haczyk!
attinat
2

PHP , 124 bajty

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;}

Wypróbuj online!

Wyjaśnienie:

Utwórz kopię tablicy wejściowej i zapętlaj każde możliwe przesunięcie echa. Dla każdej kolumny odejmij wartość w pozycji przesunięcia od odpowiedniej wartości w pierwotnej pozycji, aby określić wartość niezbędną do zsumowania danych wejściowych. Jeśli jest poprawny ( ), zastąp zawartość tej kolumny tą wartością. Kontynuuj do końca, a jeśli żadne wartości nie są nieprawidłowe, jest to poprawna odpowiedź.>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
źródło
2

Python 3 , 111 bajtów

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

Wypróbuj online!

Rozwiązanie bierze kilka pomysłów z rozwiązania @Chas Brown, takich jak struktura rekurencyjna i konstrukcja tablicy wyjściowej. Tymczasem wprowadza również pewne zmiany w kryteriach oceny, a także umieszcza pętlę for w wyrażeniu generatora, aby umożliwić rozwiązanie w jednym wierszu. Wersja bez golfa jest pokazana poniżej. Tutaj tablica outjest obliczana aż do końca tablicy wejściowej, a następnie sprawdzamy, czy wszystkie ostatnie jej lelementy są zerowe. Jeśli tak, pierwsze len(arr)-lelementy są zwracane jako odpowiedź, jeśli wszystkie są nieujemne.

Wersja bez golfisty, nierekurencyjna

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

Wypróbuj online!

Joel
źródło
1
@ 640KB Sprawdziłem, czy zwrócona odpowiedź odpowiada oczekiwanemu wynikowi w moim kodzie i drukuje wiadomość tylko w przypadku niedopasowania. Zatem brak danych wyjściowych oznacza, że ​​wszystko jest w porządku. Przyznaję, że na pierwszy rzut oka może to być mylące i zaktualizuję go później, aby wydrukować „Poprawne” na meczu.
Joel
1
@ 640 KB Zaktualizowano.
Joel
1

Węgiel , 62 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

≔⁰ζ

Załóżmy, że nie ma echa.

F⊘Lθ«

Wypróbuj wszystkie możliwe punkty początkowe echa. Uwaga: mogłem błędnie odczytać pytanie i być może nie próbowałem wystarczającej wielkości echa, w którym to przypadku nie byłoby to konieczne.

≔E⊕ι⁰η

Zacznij od tablicy zer o tym samym rozmiarze, co punkt początkowy echa.

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

Dla każdego elementu w oryginalnej tablicy odejmuj cyklicznie element w tablicy echa. W ten sposób każdy element w tablicy echa tworzy naprzemienną sumę elementów oddalających się od siebie.

¿⬤η¬κ≔⊕ιζ»

Jeśli wszystkie naprzemienne sumy są równe zero, zapisz to jako możliwy punkt początkowy. (Więc jeśli istnieje więcej niż jedna możliwość, wówczas używany jest największy możliwy punkt początkowy.)

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

Zbuduj tablicę echa, odejmując elementy za punktem początkowym od odpowiedniego wcześniej obliczonego elementu.

Iυ

Rzuć na ciąg znaków, aby uzyskać niejawne dane wyjściowe w osobnych wierszach.

Neil
źródło