Membantu! Saya sepertinya memiliki gaung yang mengganggu di beberapa array saya, dan saya ingin menyingkirkannya. Ketika ini terjadi, array asli berulang di suatu tempat di tengah menyebabkan nilai ditambahkan satu sama lain.

Misalnya, array [ 422, 375, 527, 375, 859, 451, 754, 451 ]berisi gema itu sendiri seperti:

[ 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

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

Mungkin juga tidak ada gema dalam array, dalam hal ini mengembalikan array asli:

Contoh 3:

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

Tantangan:

Diberikan array yang mungkin berisi gema, hapus dan kembalikan array tanpa gema.

Memasukkan:

• Array, daftar, string yang dibatasi, kartu berlubang atau setara dengan platform Anda, yang mengandung tiga atau lebih bilangan bulat, dalam kisaran dengan setidaknya satu elemen .$0\leq n\lt10000$$\gt 0$
• Gema tidak dapat dimulai pada elemen pertama atau setelah elemen terakhir.
• Gema hanya akan muncul sekali atau tidak sama sekali dalam input.

Keluaran:

• Array, daftar, dll bilangan bulat , dengan gema dihapus.$0\leq n\lt10000$
• Jika tidak ada gema, kembalikan array asli.

Aturan dan penilaian:

• Ini adalah kode-golf , jadi jawaban terpendek dalam byte untuk setiap bahasa menang.
• Aturan standar dan aturan I / O standar berlaku.
• Lubang terlarang (tentu saja).
• Berikan tautan dengan tes untuk kode Anda ( TIO.run , dll).
• Penjelasan yang jelas untuk jawaban Anda sangat dianjurkan.

Kasus uji:

Dengan gema:

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

Tanpa gema:

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

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

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

Divisi polinomial untuk menang!

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 byte

Pertama, penting untuk memperhatikan bahwa jika ada gema hadir, maka array input adalah lilitan array lain dengan beberapa array bentuk [1,1],[1,0,1],[1,0,0,1],....

Ini berarti kita hanya perlu memeriksa ini untuk semua array ini. Tetapi konvolusi / dekonvolusi diskrit sama dengan perkalian polinomial / pembagian panjang, jadi ini hanyalah implementasi menggunakan polinomial, setiap kali mengembalikan hasil bagi jika memungkinkan.

Salah satu trik yang sedikit memperpendek semuanya adalah selain array di atas juga memeriksa [1]sebagai kasus dasar, karena jika tidak ada array lain bekerja, dekonvolusi dengan [1]akan bekerja dan akan mengembalikan polinomial asli.

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] 

Cobalah online!

JavaScript , 211 171 145 byte

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}

Cobalah online

40 byte dari Kevin Cruijssen

Lain 26 byte dari Arnauld

Kode golf pertama saya menjawab, membatalkan potensi offset, dan mengembalikan array asli atau baru bergantung pada apa yang ditemukannya. Jika ada yang tahu bagaimana membuatnya lebih pendek, tolong beri tahu saya, sepertinya ini permainan yang menyenangkan.

Haskell, 112 111 110 byte

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]

Cobalah 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 

Bahasa Wolfram (Mathematica) , 131 129 120 119 102 98 97 96 95 byte

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

Cobalah online!

Byte1 byte berkat attinat : kita bisa menulis L=Tr[1^#]alih-alih L=Length@#ketika argumennya adalah daftar angka.

Penjelasan kode: Iterasi melalui penyusutan d(perbedaan antara panjang input dan output). Untuk setiap panjang daftar output, buat daftar yang tidak diketahui v={x[1],x[2],...,x[L-d]}dan tambahkan ke dirinya sendiri dengan bantalan kiri dan bantalan kanan ke panjang L( PadLeft[v,L]+PadRight[v,L]), kemudian atur jumlah ini sama dengan daftar input dan pecahkan untuk yang tidak diketahui x[1]...x[L-d]. Pilih solusi terpendek, yang merupakan yang terakhir dihasilkan: teruslah menimpa variabel wsetiap kali solusi ditemukan.

Versi tidak golf:

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 byte

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

Cobalah online!

Tautan monadik yang mengambil dan mengembalikan daftar bilangan bulat. Secara teknis, hasil yang sukses bersarang dalam dua daftar lebih lanjut, tetapi ketika dijalankan sebagai program lengkap, output implisit ke stdout mengabaikan daftar yang berlebihan.

Python 2 , 113 123 128 127 123 122 byte

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

Cobalah online!

1 byte thx ke TFeld ; dan 1 byte thx ke Sebastian Kreft .

Pada setiap panggilan ke f, kami membuat gema panjang potensial len(a)-i. Bagian pertama hanyalah ibyte pertama dari; sisanya dihitung sehingga 'jumlah gema' akan benar untuk bagian 'tumpang tindih' dari jumlah gema (yaitu, jumlah gema benar hingga a[:-i]).

Kemudian perbandingan yang sangat singkat, un-golf, memberikan:

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

Bahasa Wolfram (Mathematica) , 93 byte

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

Cobalah online!

Mengembalikan hadir gema terpendek dalam daftar.

PHP , 124 byte

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

Cobalah online!

Penjelasan:

Buat salinan array input dan loop melalui masing-masing kemungkinan offset gema. Untuk setiap kolom, kurangi nilai di posisi offset dari nilai yang sesuai di posisi awal untuk menentukan nilai yang diperlukan untuk menambah input. Jika itu valid ($\gt 0$), ganti konten kolom itu dengan nilai itu. Lanjutkan ke akhir dan jika tidak ada nilai yang tidak valid, itu adalah jawaban yang benar.

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 byte

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

Cobalah online!

Solusi ini mengambil beberapa ide dari solusi @Chas Brown seperti struktur rekursif dan pembangunan array output. Sementara itu, ia juga membuat beberapa perubahan dalam kriteria penilaian serta menempatkan loop for ke dalam ekspresi generator untuk memungkinkan solusi single-line. Versi ungolfed ditampilkan sebagai berikut. Di sini, arrayout dihitung sampai ujung array input dan kemudian kita periksa apakah lelemen terakhir semuanya nol. Jika demikian, len(arr)-lelemen pertama dikembalikan sebagai jawaban jika semuanya non-negatif.

Versi tidak digabungkan, non-rekursif

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

Cobalah online!

Arang , 62 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

≔⁰ζ

Asumsikan tidak ada gema.

Ｆ⊘Ｌθ«

Coba semua titik awal gema yang mungkin. Catatan: Saya mungkin salah membaca pertanyaan dan mungkin tidak mencoba ukuran gema yang cukup, dalam hal ⊘ini tidak perlu.

≔Ｅ⊕ι⁰η

Mulailah dengan larik nol dengan ukuran yang sama dengan titik awal gema.

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

Untuk setiap elemen dalam array asli, kurangi elemen dalam array echo secara siklikal darinya. Setiap elemen dalam array gema dengan demikian membangun jumlah bergantian dari elemen-elemen yang terpisah.

¿⬤η¬κ≔⊕ιζ»

Jika semua jumlah bolak-balik adalah nol, maka simpan ini sebagai titik awal yang memungkinkan. (Jadi jika ada lebih dari satu kemungkinan maka titik awal yang paling mungkin digunakan.)

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

Bangun array gema dengan mengurangi elemen setelah titik awal dari elemen yang dihitung sebelumnya yang sesuai.

Ｉυ

Keluarkan ke string untuk output implisit pada baris terpisah.