Cứu giúp! Tôi dường như có một tiếng vang khó chịu trong một số mảng của tôi, và tôi muốn loại bỏ nó. Khi điều này xảy ra, mảng ban đầu lặp lại ở đâu đó ở giữa khiến các giá trị được thêm vào nhau.

Ví dụ, mảng [ 422, 375, 527, 375, 859, 451, 754, 451 ]chứa một tiếng vang của chính nó như vậy:

[ 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

Ví dụ 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 ]

Cũng có thể là không có tiếng vang trong mảng, trong trường hợp đó trả về mảng ban đầu:

Ví dụ 3:

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

Thử thách:

Đưa ra một mảng có thể chứa tiếng vang, loại bỏ nó và trả về mảng mà không có tiếng vang.

Đầu vào:

• Một mảng, danh sách, chuỗi phân tách, thẻ đục lỗ hoặc tương đương phù hợp với nền tảng của bạn, chứa ba hoặc nhiều số nguyên, trong phạm vi $0\leq n\lt10000$ với ít nhất một phần tử $\gt 0$ .
• Tiếng vang không thể bắt đầu ở phần tử đầu tiên hoặc sau phần tử cuối cùng.
• Tiếng vang sẽ chỉ xảy ra một lần hoặc không xảy ra trong đầu vào.

Đầu ra:

• Một mảng, danh sách, vv của các số nguyên $0\leq n\lt10000$ , với tiếng vang bị loại bỏ.
• Nếu không có tiếng vang, trả về mảng ban đầu.

Quy tắc và tính điểm:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng.
• Quy tắc chuẩn và quy tắc I / O mặc định được áp dụng.
• Lỗ hổng bị cấm (tất nhiên).
• Vui lòng cung cấp liên kết với một bài kiểm tra cho mã của bạn ( TIO.run , v.v.).
• Một lời giải thích rõ ràng cho câu trả lời của bạn là rất khuyến khích.

Các trường hợp thử nghiệm:

Với tiếng vang:

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

Không có tiếng vang:

[ 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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Phân chia đa thức cho chiến thắng!

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

Đầu tiên, điều quan trọng cần lưu ý là nếu có tiếng vang, thì mảng đầu vào là một tổ hợp của một mảng khác với một số mảng có dạng [1,1],[1,0,1],[1,0,0,1],... .

Điều này có nghĩa là chúng ta chỉ cần kiểm tra điều này cho tất cả các mảng. Nhưng tích chập / giải mã rời rạc cũng giống như phép nhân đa thức / phép chia dài, vì vậy đây chỉ là một triển khai sử dụng đa thức, mỗi lần trả về thương số nếu có thể.

Một mẹo rút ngắn toàn bộ một chút là ngoài các mảng ở trên cũng kiểm tra [1]như một trường hợp cơ sở, bởi vì nếu không có mảng nào khác hoạt động, phép giải mã [1]sẽ hoạt động và sẽ trả về đa thức ban đầu.

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] 

Hãy thử trực tuyến!

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}

Dùng thử trực tuyến

40 byte từ Kevin Cruijssen

26 byte khác từ Arnauld

Câu trả lời golf mã đầu tiên của tôi, làm mất hiệu lực bù đắp tiềm năng và trả về mảng ban đầu hoặc mảng mới phụ thuộc vào những gì nó tìm thấy. Nếu ai biết cách làm cho nó ngắn hơn xin vui lòng cho tôi biết, có vẻ như là một trò chơi thú vị.

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]

Hãy thử trực tuyến!

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 

Ngôn ngữ Wolfram (Mathicala) , 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)&

Hãy thử trực tuyến!

Byte1 byte nhờ attinat : chúng ta có thể viết L=Tr[1^#]thay vì L=Length@#khi đối số là danh sách các số.

Giải thích mã: Lặp lại thông qua độ co ngót d(chênh lệch giữa độ dài đầu vào và đầu ra). Đối với mỗi độ dài danh sách đầu ra, xây dựng một danh sách các ẩn số v={x[1],x[2],...,x[L-d]}và thêm nó vào phần đệm bên trái và phần đệm bên phải theo chiều dài L( PadLeft[v,L]+PadRight[v,L]), sau đó đặt tổng này bằng với danh sách đầu vào và giải quyết các ẩn số x[1]...x[L-d]. Chọn giải pháp ngắn nhất, là giải pháp cuối cùng được tạo: chỉ cần ghi đè lên biếnw mỗi khi tìm thấy giải pháp.

Phiên bản chưa chơi gôn:

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

Thạch , 25 24 byte

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

Hãy thử trực tuyến!

Một liên kết đơn sẽ lấy và trả về một danh sách các số nguyên. Về mặt kỹ thuật, các kết quả thành công được lồng trong hai danh sách tiếp theo, nhưng khi được chạy dưới dạng một chương trình đầy đủ, đầu ra ẩn cho thiết bị xuất chuẩn sẽ bỏ qua các danh sách dự phòng.

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

Hãy thử trực tuyến!

1 byte thx đến TFeld ; và 1 byte thx cho Sebastian Kreft .

Trên mỗi cuộc gọi đến f, chúng tôi xây dựng một tiếng vang tiềm năng về độ dàilen(a)-i . Phần đầu tiên chỉ là các ibyte đầu tiên của a; phần còn lại được tính toán sao cho 'tổng âm vang' sẽ chính xác cho phần 'chồng chéo' của tổng âm vang (nghĩa là tổng âm vang chính xác đếna[:-i] ).

Sau đó, so sánh rất ngắn, không đánh gôn, đưa ra:

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

Ngôn ngữ Wolfram (Mathicala) , 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)&

Hãy thử trực tuyến!

Trả về tiếng vang ngắn nhất trong danh sách.

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

Hãy thử trực tuyến!

Giải trình:

Tạo một bản sao của mảng đầu vào và lặp qua từng phần bù có thể của tiếng vang. Đối với mỗi cột, hãy trừ giá trị ở vị trí bù khỏi giá trị tương ứng ở vị trí ban đầu để xác định giá trị cần thiết để thêm vào đầu vào. Nếu nó hợp lệ ($\gt 0$), thay thế nội dung của cột đó bằng giá trị đó. Tiếp tục đến cuối và nếu không có giá trị nào không hợp lệ, đó là một câu trả lời đúng.

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

Hãy thử trực tuyến!

Giải pháp lấy một số ý tưởng từ giải pháp của @Chas Brown, chẳng hạn như cấu trúc đệ quy và xây dựng mảng đầu ra. Trong khi đó, nó cũng thực hiện một số thay đổi trong tiêu chí đánh giá cũng như đưa vòng lặp for vào biểu thức trình tạo để cho phép giải pháp một dòng. Các phiên bản không được trình bày được hiển thị dưới đây. Ở đây, mảng outđược tính toán cho đến hết mảng đầu vào và sau đó chúng tôi kiểm tra xem cuối cùngl phần tử của nó có bằng không hay không. Nếu vậy, đầu tiênlen(arr)-l phần tử được trả về làm câu trả lời nếu tất cả chúng không âm.

Ungolfed, phiên bản không đệ quy

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

Hãy thử trực tuyến!

Than , 62 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔⁰ζ

Giả sử không có tiếng vang.

Ｆ⊘Ｌθ«

Hãy thử tất cả các điểm bắt đầu có thể của tiếng vang. Lưu ý: Tôi có thể đã đọc sai câu hỏi và có thể không thử đủ kích cỡ tiếng vang, trong trường hợp đó là ⊘không cần thiết.

≔Ｅ⊕ι⁰η

Bắt đầu với một mảng các số không có cùng kích thước với điểm bắt đầu của tiếng vang.

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

Đối với mỗi phần tử trong mảng ban đầu, hãy trừ phần tử trong mảng echo theo chu kỳ từ nó. Do đó, mỗi phần tử trong mảng echo sẽ tạo ra tổng xen kẽ của các phần tử cách nhau.

¿⬤η¬κ≔⊕ιζ»

Nếu tất cả các khoản tiền xen kẽ bằng 0 thì hãy lưu số này làm điểm bắt đầu có thể. (Vì vậy, nếu có nhiều hơn một khả năng thì điểm bắt đầu lớn nhất có thể được sử dụng.)

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

Xây dựng mảng lặp lại bằng cách trừ các phần tử sau điểm bắt đầu từ phần tử được tính toán thích hợp trước đó.

Ｉυ

Truyền tới chuỗi cho đầu ra ngầm định trên các dòng riêng biệt.