मेरी सरणी में एक गूंज है ... मेरी सरणी में गूंज ... मेरी सरणी

34

मदद! मुझे लगता है कि मेरी कुछ सरणियों में एक कष्टप्रद गूंज है, और मैं इससे छुटकारा पाना चाहूंगा। जब ऐसा होता है, तो मूल सरणी बीच में ही कहीं दोहराती है, जिससे मान एक दूसरे में जुड़ जाते हैं।

उदाहरण के लिए, सरणी [ 422, 375, 527, 375, 859, 451, 754, 451 ]में स्वयं की एक प्रतिध्वनि होती है जैसे:

[ 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

उदाहरण 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 ]

यह भी संभव है कि सरणी में कोई प्रतिध्वनि न हो, जिस स्थिति में मूल सरणी लौटें:

उदाहरण 3:

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

चुनौती:

एक ऐसी सरणी को देखते हुए जिसमें एक प्रतिध्वनि हो सकती है, उसे हटा दें और बिना प्रतिध्वनि के सरणी को लौटा दें।

इनपुट:

  • एक सरणी, सूची, सीमांकित स्ट्रिंग, छिद्रित कार्ड या आपके प्लेटफ़ॉर्म-उपयुक्त समकक्ष, जिसमें कम से कम एक तत्व साथ की सीमा में तीन या अधिक पूर्णांक होते हैं ।0≤n<10000>0
  • गूंज पहले या अंतिम तत्व के बाद शुरू नहीं हो सकती।
  • इको केवल इनपुट के भीतर एक बार या बिल्कुल नहीं होगा।

आउटपुट:

  • पूर्णांक के साथ पूर्णांक एक सरणी, सूची, आदि ।0≤n<10000
  • यदि कोई गूंज नहीं है, तो मूल सरणी लौटें।

नियम और स्कोरिंग:

परीक्षण के मामलों:

प्रतिध्वनि के साथ:

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

बिना प्रतिध्वनि के:

[ 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 ]
code-golf  array-manipulation  algorithm 
— 640KB
स्रोत
3
क्या होगा यदि कई संभावित आउटपुट हैं? इनपुट [1, 2, 2, 2, 1]:; आउटपुट: [1, 1, 1, 1]बनाम[1, 2, 1]
— टीएच
3
के लिए उम्मीद उत्पादन क्या है [1, 2, 3, 1, 2, 3], [1, 2, 3, 0, 1, 2, 3], [0, 1, 3, 2, 0]? वर्तमान उत्तर इन सभी इनपुटों पर सहमत नहीं हैं।
— tsh
@tsh या तो ( [1, 1, 1, 1]बनाम [1, 2, 1]) स्वीकार्य हैं। मेरे पास मूल रूप से एक नियम था जिसके बारे में चुनना था, लेकिन इसे सैंडबॉक्स में बंद कर दिया क्योंकि यह केवल किनारे के मामलों की एक छोटी संख्या पर लागू होता था।
— 640KB
@tsh, [0, 1, 3, 2, 0]होना चाहिए [0, 1, 2, 0]- मैंने परीक्षण मामलों में जोड़ा है। अन्य दो पर अपेक्षित उत्तर [1, 2, 3]हालांकि मैं नियमों के अनुसार उन वैध परीक्षण मामलों पर विचार नहीं कर सकता the original array repeats itself somewhere in the middle।
— 640KB
1
@ नमि गुड। मैं कहूंगा कि यह अस्पष्ट है [0,0,0](या किसी भी आकार के सभी- 0सरणी) किसी भी चीज़ की एक प्रतिध्वनि का प्रतिनिधित्व करता है या यदि [0,0,0](कोई प्रतिध्वनि) इस विशेष मामले के लिए भी एक मान्य उत्तर होगा, साथ ही यह निर्धारित करने के लिए पर्याप्त जानकारी नहीं है यह है। मैं इसे वैध इनपुट होने से प्रतिबंधित करने के लिए नियमों को अपडेट करूंगा, क्योंकि यह किसी मौजूदा जवाब को अमान्य या परिवर्तित नहीं करेगा।
— 640KB

जवाबों:

8

MATL , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

जीत के लिए बहुपद विभाजन!

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
— लुइस मेंडो
स्रोत
इस पर "एसो" या "ऐतिहासिक" भाषा पर कोई प्रतिशोधी नहीं ... इसलिए इनाम लोकप्रियता में जाता है!
— 640KB
1
@ 640KB मुझे नहीं पता था कि इस चुनौती पर कोई इनाम था! धन्यवाद!
— लुइस मेंडू
7

हास्केल , 167 बाइट्स

पहले यह ध्यान रखना महत्वपूर्ण है कि यदि कोई प्रतिध्वनि मौजूद है, तो इनपुट सरणी फॉर्म के कुछ सरणी के साथ दूसरे सरणी का एक कनवल्शन है [1,1],[1,0,1],[1,0,0,1],...।

इसका मतलब है कि हमें इन सभी सरणियों के लिए इसे जांचना होगा। लेकिन असतत कनवल्शन / डेकोनोवोल्यूशन बहुपद गुणन / लंबे विभाजन के समान है, इसलिए यह संभवत: बहुपदों का उपयोग करते हुए एक कार्यान्वयन है, यदि संभव हो तो भागफल को वापस करते हुए हर बार।

एक ट्रिक जिसने पूरी चीज़ को थोड़ा छोटा कर दिया था, ऊपर दिए गए एरे के अलावा [1]बेस केस के रूप में भी जाँच कर रहा था , क्योंकि यदि कोई अन्य ऐरे काम नहीं करता है, तो विमोचन [1]कार्य करेगा और मूल बहुपद को लौटा देगा।

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]

इसे ऑनलाइन आज़माएं!

— flawr
स्रोत
आधार मामले के साथ अच्छी चाल! मैंने अपने उत्तर में इसे शामिल करने की कोशिश की, लेकिन मैं कोड को छोटा कर सकता था
— लुइस मेंडू
4

जावास्क्रिप्ट , 211 171 145 बाइट्स

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}

इसे ऑनलाइन आज़माएं

केविन क्रूज़सेन से 40 बाइट्स

अरनौलद से एक और 26 बाइट्स

मेरा पहला कोड गोल्फ उत्तर, संभावित ऑफ़सेट्स को अमान्य कर देता है, और जो भी पाता है, उस पर निर्भर मूल या नए सरणी को वापस कर देता है। अगर किसी को पता है कि इसे छोटा कैसे बनाया जाए तो pls मुझे बताएं, एक मजेदार गेम लगता है।

— लेवी ने कहा
स्रोत
1
मैं भी जावास्क्रिप्ट के साथ दक्ष नहीं हूँ, लेकिन कुछ बुनियादी golfs साथ (यानी अनावश्यक कोष्ठक, को दूर करने के नियुक्तियों में परिवर्तन ++, बदल रहा है &&करने के लिए &, सबसे पहले देखें में दोनों को बदलने .toString()के लिए +'', आदि) मैं करने के लिए नीचे अपने कोड मिला 181 बाइट्स । यदि आपने उन्हें अभी तक नहीं देखा है, तो जावास्क्रिप्ट में युक्तियाँ और सभी भाषाओं में गोल्फ के लिए युक्तियाँ पढ़ने के लिए दिलचस्प हो सकता है। :)
— केविन क्रूज़सेन
1
ओह, एक भूल गया ( function q(s)हो सकता है s=>): 171 बाइट्स । यहां रहने का आनंद! :)
— केविन क्रूज़सेन
उस के लिए धन्यवाद, मैं एक पढ़ा होगा। मैं जावास्क्रिप्ट के साथ बहुत काम नहीं कर रहा हूँ, लेकिन मुझे हाल ही में कुछ करना पड़ा है और मुझे लगा कि मेरे डाउनटाइम में थोड़ा ब्रश करने का यह एक अच्छा तरीका हो सकता है
— लेवी फेद
1
कुछ और (सभी परीक्षणों के बिना ताकि यह इस टिप्पणी में एक प्रत्यक्ष यूआरएल के रूप में फिट बैठता है)
— Arnauld
1
कोड गोल्फ एसई में आपका स्वागत है! हमें उम्मीद है कि आप यहां अपना समय गुजारने का आनंद लेंगे!
— Giuseppe
3

हास्केल, 112 111 110 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

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
स्रोत
3

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 131 129 120 119 102 98 97 96 95 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Can1 बाइट अटारी के लिए धन्यवाद : हम L=Tr[1^#]इसके बजाय लिख सकते हैं L=Length@#जब तर्क संख्याओं की एक सूची है।

कोड स्पष्टीकरण: संकोचन d(इनपुट और आउटपुट लंबाई के बीच अंतर) के माध्यम से Iterate । प्रत्येक आउटपुट सूची की लंबाई के लिए, अज्ञात की एक सूची बनाएं v={x[1],x[2],...,x[L-d]}और इसे स्वयं बाएं-पैडेड और राइट-पैडेड लंबाई L( PadLeft[v,L]+PadRight[v,L]) में जोड़ें, फिर इस राशि को इनपुट सूची के बराबर सेट करें और अज्ञात के लिए हल करें x[1]...x[L-d]। सबसे छोटा समाधान चुनें, जो पिछले एक उत्पन्न होता है: बस wहर बार एक समाधान मिलने पर चर को लिखना जारी रखें ।

गैर-गोल्फ संस्करण:

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 *)
— रोमन
स्रोत
-1 की Tr[1^#]जगहLength@#
— अत्तिनत
2

जेली , 25 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक मोनडिक लिंक जो पूर्णांकों की एक सूची लेता है और लौटाता है। तकनीकी रूप से, सफल परिणामों को दो और सूचियों में नस्ट किया जाता है, लेकिन जब एक पूर्ण कार्यक्रम के रूप में रनआउट करने के लिए निहित आउटपुट अनावश्यक सूचियों को अनदेखा करता है।

— निक केनेडी
स्रोत
2

अजगर 2 , 113 123 128 127 123 123 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 बाइट thx से TFeld ; और 1 बाइट thx से सेबस्टियन क्रेफट ।

प्रत्येक कॉल पर f , हम लंबाई की एक संभावित प्रतिध्वनि का निर्माण करते हैं len(a)-i। पहला भाग सिर्फ पहला iबाइट्स है a; शेष की गणना इसलिए की जाती है कि प्रतिध्वनि योग के 'अतिव्याप्त' खंड के लिए 'प्रतिध्वनि योग' सही होगा (यानी प्रतिध्वनि योग सही है a[:-i])।

फिर बहुत छोटी कटी हुई तुलना, बिना गोल्फ वाली, देता है:

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
— चास ब्राउन
स्रोत
e+=[v-e[-i]]हो सकता हैe+=v-e[-i],
— TFeld
आप ऐसा करके एक और चरित्र को शेव कर सकते हैंi<=len(a)/2
— सेबेस्टियन क्रेफट
2

वोल्फ्राम भाषा (गणितज्ञ) , 93 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सूची में मौजूद सबसे छोटी प्रतिध्वनि लौटाता है।

— attinat
स्रोत
ऐसा लगता है कि यह विफल रहता है {1,1,1}और पर {1,0,1}।
— रोमन
@Roman उन मामलों में से किसी के लिए कोई प्रतिध्वनि नहीं है?
— २१:०२ में
के लिए {1,1,1}कोई गूंज नहीं है, मूल सरणी वापस जाने के लिए, ताकि आप की जरूरत है। क्योंकि {1,0,1}मैं कहता हूँ कि प्रतिध्वनि है, {1}लेकिन स्वीकार करते हैं कि यह थोड़ा अस्पष्ट है कि नियम क्या हैं।
— रोमन
ठीक है। पकड़ने के लिए धन्यवाद!
— अटारीट
2

PHP , 124 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

इको की प्रत्येक संभावित ऑफसेट के माध्यम से इनपुट ऐरे और लूप की एक प्रति बनाएँ। प्रत्येक कॉलम के लिए, इनपुट को जोड़ने के लिए आवश्यक मूल्य निर्धारित करने के लिए मूल स्थिति में संबंधित मूल्य से ऑफसेट स्थिति में मूल्य घटाएं। यदि यह मान्य है (>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;
}
— 640KB
स्रोत
2

पायथन 3 , 111 बाइट्स

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

इसे ऑनलाइन आज़माएं!

समाधान @ चास ब्राउन के समाधान से कुछ विचार लेता है जैसे कि पुनरावर्ती संरचना और आउटपुट सरणी का निर्माण। इस बीच, यह जजिंग मानदंड में कुछ बदलाव भी करता है और लूप के लिए एक सिंगल-लाइन सॉल्यूशन की अनुमति देने के लिए जनरेटर अभिव्यक्ति में डालता है। अनलॉक्ड संस्करण को निम्नलिखित में दिखाया गया है। यहां, सरणी outको इनपुट सरणी के अंत में सभी तरह से गणना की जाती है और फिर हम जांचते हैं कि क्या इसके अंतिम lतत्व सभी शून्य हैं। यदि हां, तो पहले len(arr)-lतत्वों को उत्तर के रूप में लौटा दिया जाता है यदि उनमें से सभी गैर-नकारात्मक हैं।

अनगुल्ड, गैर-पुनरावर्ती संस्करण

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

इसे ऑनलाइन आज़माएं!

— जोएल
स्रोत
1
@ 640KB मैंने जाँच की कि लौटाया गया उत्तर मेरे कोड में अपेक्षित परिणाम से मेल खाता है या नहीं तो केवल संदेश है। इसलिए कोई आउटपुट का मतलब सब कुछ सही नहीं है। मैं मानता हूं कि यह पहली नज़र में भ्रामक हो सकता है और मैं इसे बाद में एक मैच पर "सही" प्रिंट करने के लिए अपडेट करूंगा।
— जोएल
1
@ 640KB अपडेट किया गया।
— जोएल
1

चारकोल , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⁰ζ

मान लें कि कोई गूंज नहीं है।

Ｆ⊘Ｌθ«

गूंज के सभी संभव प्रारंभ बिंदुओं का प्रयास करें। नोट: मैंने इस प्रश्न को गलत समझा हो सकता है और हो सकता है कि यह प्रतिध्वनि के पर्याप्त आकारों की कोशिश न कर रहा हो, जिस स्थिति में ⊘यह आवश्यक नहीं होगा।

≔Ｅ⊕ι⁰η

शून्य के एक सरणी के साथ प्रारंभ के रूप में एक ही आकार शुरू करें।

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

मूल सरणी में प्रत्येक तत्व के लिए, इको सरणी में तत्व को उससे चक्रीय रूप से घटाएं। इको एरे में प्रत्येक तत्व इस प्रकार अलग-अलग होने वाले तत्वों के वैकल्पिक योग को बनाता है।

¿⬤η¬κ≔⊕ιζ»

यदि सभी वैकल्पिक रकम शून्य हैं तो इसे संभावित आरंभ बिंदु के रूप में सहेजें। (इसलिए यदि एक से अधिक संभावना है तो सबसे बड़ा संभव प्रारंभ बिंदु का उपयोग किया जाता है।)

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

उपयुक्त पूर्व परिकलित तत्व से प्रारंभ बिंदु के बाद तत्वों को घटाकर गूंज सरणी बनाएँ।

Ｉυ

अलग लाइनों पर अंतर्निहित उत्पादन के लिए स्ट्रिंग के लिए कास्ट करें।

— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.