Yardım et! Dizilerimin bazılarında sinir bozucu bir yankı var gibi görünüyor ve ondan kurtulmak istiyorum. Bu olduğunda, orjinal dizi kendini ortada bir yerde tekrarlar ve değerlerin birbirine eklenmesine neden olur.

Örneğin, dizi şöyle [ 422, 375, 527, 375, 859, 451, 754, 451 ]bir yankı içerir:

[ 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

Örnek 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 ]

Ayrıca dizide eko olmaması da mümkündür, bu durumda orijinal diziyi döndürür:

Örnek 3:

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

Meydan okuma:

Bir eko içerebilen bir dizi göz önüne alındığında, onu kaldırın ve diziyi bir eko olmadan döndürün.

Giriş:

• Bir dizi, liste, sınırlandırılmış dize, delikli kartlar veya platforma uygun eşdeğer, üç veya daha fazla tam sayı içeren, $0\leq n\lt10000$ aralığında, en az bir element $\gt 0$ .
• Yankı, ilk veya son elemandan sonra başlayamaz.
• Eko, girdi içinde yalnızca bir kez gerçekleşir veya hiç olmaz.

Çıktı:

• Yankı kaldırılmış $0\leq n\lt10000$ tamsayıları dizisi, listesi vb .
• Yankı yoksa, orijinal diziyi döndürün.

Kurallar ve puanlama:

• Bu kod golf , her dil için bayt cinsinden en kısa cevap kazanır.
• Standart kurallar ve varsayılan G / Ç kuralları uygulanır.
• Yasak halkalar (tabii ki).
• Lütfen kodunuz için bir test sağlayın ( TIO.run vb.)
• Cevabınız için net bir açıklama şiddetle tavsiye edilir.

Test durumları:

Yankı ile:

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

Yankı olmadan:

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

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

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

Polinom kazanma şansı!

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 bayt

Öncelikle, eğer bir yankı varsa, o zaman girdi dizisinin, formun bir dizisi olan başka bir dizinin evrişimi olduğunu fark etmek önemlidir [1,1],[1,0,1],[1,0,0,1],....

Bu, tüm bu diziler için bunu kontrol etmemiz gerektiği anlamına gelir. Ancak ayrık evrişim / dekonvolüsyon, polinom çarpımı / uzun bölünme ile aynıdır, bu yüzden bu, mümkünse her zaman bölümü geri döndüren polinomları kullanan bir uygulamadır.

Her şeyi biraz kısaltan bir püf noktası, yukarıdaki dizilere ek [1]olarak temel bir durum olarak da kontrol etmekti , çünkü başka bir dizi [1]çalışmazsa , ile dekonvolüsyon çalışacak ve orijinal polinomu geri getirecektir.

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] 

Çevrimiçi deneyin!

JavaScript , 211 171 145 bayt

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}

Çevrimiçi deneyin

40 bayt Kevin Cruijssen'dan

Arnauld'dan 26 bayt daha

İlk kod golf cevabım, potansiyel ofsetleri geçersiz kılar ve bulduğu şeye bağlı olarak orijinali veya yeni diziyi döndürür. Birisi nasıl kısaltılacağını bilen varsa pls bana bildirin, eğlenceli bir oyun gibi görünüyor.

Haskell, 112 111 110 bayt

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]

Çevrimiçi deneyin!

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 Dili (Matematik) , 131 129 120 119 102 98 97 96 95 bayt

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

Çevrimiçi deneyin!

İnat1 bayt attinat sayesinde : L=Tr[1^#]yerine yazabilirizL=Length@# argüman numarası listesi olduğunda.

Kod açıklaması: Büzülmeyi tekrarlayın d(giriş ve çıkış uzunlukları arasındaki fark). Her bir çıkış listesi uzunluğu için, bilinmeyenlerin bir listesini oluşturun v={x[1],x[2],...,x[L-d]}ve kendisinin sol ya da sağa yastığın boyuna L( PadLeft[v,L]+PadRight[v,L]) ekleyin , ardından bu toplamı giriş listesine eşit olarak ayarlayın ve bilinmeyenler için çözün x[1]...x[L-d]. Üretilen son çözüm olan en kısa çözümü seçin: sadece wbir çözüm bulunduğunda değişkenin üzerine yazmaya devam edin .

Golfsüz versiyon:

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

Jöle , 25 24 bayt

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

Çevrimiçi deneyin!

Bir tamsayı listesi alıp veren bir tekli bağlantı. Teknik olarak, başarılı sonuçlar iki başka listeye yerleştirilir, ancak tam bir program olarak çalıştırıldığında stdout'a örtük çıktı gereksiz listeleri yok sayar.

Python 2 , 113 123 128 127 123 122 bayt

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

Çevrimiçi deneyin!

TFeld'e 1 byte thx ; ve 1 Kreta Sebastian Kreft. .

Her çağrımızda fpotansiyel bir uzunluk yankısı inşa ediyoruz len(a)-i. İlk bölüm a'nın yalnızca ilk ibaytıdır; geri kalan, 'eko toplamı', eko toplamının 'örtüşen' bölümü için doğru olacak şekilde hesaplanır (yani, eko toplamı doğru olur a[:-i]).

Daha sonra çok kısa kesimli karşılaştırma, golf yapmadan, verir:

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 Dili (Mathematica) , 93 bayt

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

Çevrimiçi deneyin!

Listedeki en kısa ekoyu döndürür.

PHP , 124 bayt

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

Çevrimiçi deneyin!

Açıklama:

$\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 bayt

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

Çevrimiçi deneyin!

Çözüm , özyinelemeli yapı ve çıktı dizisinin yapısı gibi @Chas Brown'ın çözümünden bazı fikirler alıyor . Bu arada, aynı zamanda değerlendirme kriterlerinde bazı değişiklikler yapmanın yanı sıra for döngüsünü tek satırlı bir çözüme izin vermek için bir üreteç ifadesine koyuyor. Ungolfed versiyonu aşağıda gösterilmiştir. Burada, dizi outgiriş dizisinin sonuna kadar hesaplanır ve son lelemanlarının sıfır olup olmadığını kontrol ederiz . Eğer öyleyse, ilklen(arr)-l hepsi negatif değilse unsurlar cevap olarak geri gönderilir.

Ungolfed, özyinelemeli olmayan versiyon

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

Çevrimiçi deneyin!

Kömür , 62 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

≔⁰ζ

Eko olmadığını farz et.

Ｆ⊘Ｌθ«

Yankının tüm olası başlangıç ​​noktalarını dene. Not: Soruyu yanlış anlamış olabilirim ve yeterince eko denemiyor olabilirim, bu durumda ⊘gerekli olmaz.

≔Ｅ⊕ι⁰η

Yankının başlangıç ​​noktasıyla aynı boyutta bir dizi sıfırla başlayın.

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

Orijinal dizideki her öğe için, eko dizisindeki öğeyi döngüsel olarak ondan çıkarın. Böylece, yankı dizisindeki her eleman birbirinden uzaklaşan elementlerin değişken toplamını oluşturur.

¿⬤η¬κ≔⊕ιζ»

Değişen toplamların tümü sıfırsa, bunu olası bir başlangıç ​​noktası olarak kaydedin. (Eğer birden fazla ihtimal varsa, mümkün olan en büyük başlangıç ​​noktası kullanılır.)

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

Yankı dizisini, başlangıç ​​noktasından sonra, önceden hesaplanmış uygun elementten elemanları çıkararak oluşturun.

Ｉυ

Ayrı satırlarda örtük çıktı için dizgiye yayın.