इस SO प्रश्न से प्रेरित

इनपुट के रूप में आपको पूर्णांकों की एक गैर-रिक्त सूची दी जाएगी, जहां पहला मूल्य गैर-शून्य होने की गारंटी है। आउटपुट का निर्माण करने के लिए, सूची की शुरुआत से चलें, रास्ते में प्रत्येक गैर-शून्य मान का आउटपुट करें। जब आप एक शून्य का सामना करते हैं, तो इसके बजाय आप हाल ही में आउटपुट में जोड़े गए मूल्य को दोहराएं।

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

बाइट्स में सबसे छोटा कोड जीतता है।

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

[1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9] -> [1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9]
[1, 0, 0, 0, 0, 0] -> [1, 1, 1, 1, 1, 1]
[-1, 0, 5, 0, 0, -7] -> [-1, -1, 5, 5, 5, -7]
[23, 0, 0, -42, 0, 0, 0] -> [23, 23, 23, -42, -42, -42, -42]
[1, 2, 3, 4] -> [1, 2, 3, 4]
[-1234] -> [-1234]

code-golf array-manipulation

— FryAmTheEggman
स्रोत

21

थोडा ट्रिविया: आँकड़ों की दुनिया में इस ऑपरेशन का नाम LOCF है (अंतिम अवलोकन आगे किया गया) इंप्यूटेशन।

— एलेक्स ए।

इनपुट होता तो क्या होता [0,0]?

— क्रिक्टी लिथोस

4

@ Kρι whereικσιΛίθος "... जहां पहला मूल्य गैर-शून्य होने की गारंटी है"

— Sp3000

यदि इनपुट है तो क्या होगा [1,01]? इस्साक के पाइथ उत्तर का उपयोग करके, इस और इस की तुलना करें ।

— आर्कटुरस

@ ईडन 01पायथ इनपुट में एक वैध पूर्णांक नहीं है, इसलिए आईसैक को इसके लिए खाता नहीं है। अन्य उत्तर इनपुट को स्वीकार कर सकते हैं जैसे कि यदि वे चाहते हैं, तो बस तब तक जब तक वे सुसंगत हैं (जैसे कि कैसे है इसहाक का उत्तर आउटपुट के रूप में उस सूची का उत्पादन नहीं करेगा)

— FryAmTheEggman

19

अजगर, 6 बाइट्स

mJ|dJQ

प्रदर्शन

m ... Qइसका मतलब यह है कि इनपुट पर एक फ़ंक्शन मैप करता है। फंक्शन मैप किया जा रहा है J|dJ। इसका मतलब है कि J = d or Jपायथन में, चूंकि Jपहले उपयोग पर निम्नलिखित मूल्य को सौंपा गया है। पायथन के विपरीत, असाइनमेंट एक्सप्रेशंस पाइथ में दिए गए मान को लौटाते हैं, इसलिए मानचित्र Jवांछित के प्रत्येक क्रमिक मान को लौटाता है ।

— isaacg
स्रोत

23

जेली , गैर-प्रतिस्पर्धात्मक

3 बाइट्स यह उत्तर गैर-प्रतिस्पर्धात्मक है, क्योंकि यह चुनौती को स्थगित करने वाली विशेषताओं का उपयोग करता है।

o@\

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

यह काम किस प्रकार करता है

o      Take the logical OR of its arguments.
 @     Reverse the argument order of the link to the left.
  \    Do a cumulative reduce, using the link to the left.

— डेनिस
स्रोत

6

मेरा दिमाग समझ नहीं सकता ... डेनिस ने आखिरकार हमें गोल्फ से हमेशा के लिए बाहर निकालने का रास्ता खोज लिया। जैसे वह पहले से ही नहीं था। ಠ_15

— Addison Crump

1

स्पष्टीकरण अब कार्यक्रम के साथ संरेखित नहीं करता है

— क्विंटोपिया

18

रूबी, 25 बाइट्स

->a{a.map{|x|x==0?a:a=x}}

यह वास्तव में वास्तव में बुराई है।

विशेष रूप से, स्निपेट x==0 ? a : (a=x)।

अगर मैंने किसी अन्य चर नाम का इस्तेमाल किया हो a(पिछले नॉनजरो मूल्य के लिए) -लेट के कहने पर- yमुझे इसे बाहर घोषित करना होगा map(क्योंकि y=xउस एकल mapपुनरावृत्ति के अंदर केवल एक गुंजाइश होगी )। यह चार वर्णों का अधिक उपयोग करेगा ( y=0;)।

लेकिन अगर मैं चर नाम का उपयोग करता हूं a... हां, तो आपने अनुमान लगाया। मैं वास्तव में इस तर्क पर भरोसा कर रहा हूं कि हमें इनपुट (मूल सरणी) के रूप में मिला है ।

mapपरवाह नहीं है क्योंकि यह केवल उस चीज़ के मूल मूल्य की परवाह करता है जिस पर उसे बुलाया जा रहा है, इसलिए यह वास्तव में काम करता है।

— Doorknob
स्रोत

17

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

a%0=a
a%b=b
scanl1(%)

(अनाम) फ़ंक्शन हम बनाते हैं जो अंतिम पंक्ति में है। पहली दो पंक्तियाँ एक सहायक कार्य को परिभाषित करती हैं।

scanl1(%) [1,0,2,0,7,7,7,0,5,0,0,0,9]
[1,1,2,2,7,7,7,7,5,5,5,5,9]

बाइनरी फ़ंक्शन %दूसरे तर्क को आउटपुट करता है, जब तक कि यह नहीं है 0, इस मामले में यह इसके बजाय पहले तर्क को आउटपुट करता है। scanl1इनपुट चरण पर इस फ़ंक्शन को पुनरावृत्त करता है, परिणाम को प्रत्येक चरण पर आउटपुट करता है।

— XNOR
स्रोत

13

जे, 8 बाइट्स

{:@-.&0\

यह एक यूनीरी फंक्शन है, जिसे निम्न प्रकार से किया जाता है

   f =: {:@-.&0\
   f 2 0 0 4 0 _1 0
2 2 2 4 4 _1 _1

व्याख्या

{:@-.&0\
       \  Map over non-empty prefixes:
   -.      remove all occurrences
     &0    of the number 0 and
{:@        take the last element.

— Zgarb
स्रोत

क्या आप 0s को हटाने के बजाय निरपेक्ष मान द्वारा दोहरा सकते हैं?

— lirtosiast

@ThomasKwa यह मेरा पहला प्रयास था। यह है {:@(#~|)\, इसलिए एक बाइट लंबी है।

— ज़गरब

13

पाल, 8

/^0$/g
h

/^0$/एक रेखा पर एक शून्य से मेल खाता है - यदि ऐसा है तो gपकड़ स्थान को पैटर्न स्थान पर कॉपी करता है
h पैटर्न स्पेस को होल्ड स्पेस पर कॉपी करता है

इंटेगर नई लाइन से अलग हो गए हैं। उदाहरण के लिए:

$ printf -- "-1\n0\n5\n0\n0\n7\n" | sed -f zerocover.sed
-1
-1
5
5
5
7
$

— डिजिटल आघात
स्रोत

11

जावास्क्रिप्ट ईएस 6, 19 बाइट्स

s=>s.map(i=>p=i||p)

सीधे समाधान, इनपुट के माध्यम से लूप, pवर्तमान तत्व को असाइन करें iया pयदि iहै 0और इसे आउटपुट करें।

उदाहरण रन (अनाम फ़ंक्शन असाइन करना f):

>> f([1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9])
<< Array [1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9]

— Dendrobium
स्रोत

जब भी मैं इसे चलाता हूं तो मुझे एक त्रुटि मिलती है जो कहती है कि "वेरिएबल पी नहीं पा सकते हैं"

— डाउन्गोएट

@Downgoat ऐसा इसलिए है क्योंकि दुभाषिया एक सख्त तरीका है केवल दुभाषिया। यदि आप उस कोड को सख्त मोड में नहीं चलाते हैं, तो उसे काम करना चाहिए।

— wizzwizz4

@ wizzwizz4 ओह, आर ओके

— डाउनगोट

1

@ wizzwizz4 सख्त मोड मूर्खतापूर्ण है।

— SuperJedi224

1

@ SuperJedi224 यह मूर्खतापूर्ण नहीं है। बहुत काम का है; यह सुनिश्चित करता है कि आपका कोड अस्पष्ट नहीं है, और एक बड़े अपडेट के साथ भी काम करेगा, और अपरिभाषित व्यवहार आदि का उपयोग नहीं करता है, लेकिन जो मूर्खतापूर्ण रूप से इसे सक्षम कर रहा है, क्योंकि सख्त मोड खुद को बंद करने का एक तरीका निर्दिष्ट नहीं करता है। , और यदि आप शुरुआत में सख्त मोड स्ट्रिंग नहीं डालते हैं, तो आप इसे नहीं चाहते हैं और / या कोड-गोल्फिंग कर रहे हैं।

— wizzwizz4 18

7

रेटिना , 15 बाइट्स

+`(\S+) 0
$1 $1

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

बार-बार एक नंबर की जगह एक शून्य के बाद दो बार उस नंबर के साथ आता है जब तक कि स्ट्रिंग बदलना बंद न हो जाए।

— मार्टिन एंडर
स्रोत

7

डायलॉग एपीएल, 12 10 9 बाइट्स

(⊃0~⍨,⍨)\

@ ज़र्गब के जे जवाब से प्रेरित।

(⊃0~⍨,⍨)\      Monadic function:
        \      Cumulative reduce by
(⊃0~⍨,⍨)       the dyadic function:
     ,⍨           Arguments concatenated in reverse order
  0~⍨             With zeroes removed
 ⊃                Take the first element

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

6

पायथ, 8 बाइट्स

t.u|YNQ0

बेस केस 0 के साथ (पायथन के ) .uद्वारा उपयोग (संचयी कम) ।|or

— lirtosiast
स्रोत

@ आइसाकग ऐसा लगता है जैसे .uलंबे समय तक भी है Jऔर Kबंधे हुए हैं। क्या यह कभी इष्टतम है?

— lirtosiast

यह (कम से कम afaik) यहाँ था । यह आमतौर पर तब मदद करता है जब आप किसी कारण से सभी परिणाम चाहते हैं।

— FryAmTheEggman

5

पायथन 2, 29 बाइट्स

while 1:x=input()or x;print x

प्रति पंक्ति एक संख्या के रूप में इनपुट लेता है, और एक ही प्रारूप में आउटपुट करता है। परिष्करण के बाद त्रुटि के साथ निर्देश।

के शॉर्ट-सर्कुलेटिंग नेचर का उपयोग करते हुए or, वेरिएबल xको इनपुट में अपडेट किया जाता है, जब तक कि इनपुट 0 (जो कि फाल्सी है) नहीं होता है, इस स्थिति में यह अपना वर्तमान मूल्य बना रहता है। फिर, xमुद्रित किया जाता है। ध्यान दें कि चूंकि पहली सूची का मूल्य नॉनजरो है, xइसलिए इसे असाइन किए जाने से पहले दाहिने हाथ की ओर का मूल्यांकन नहीं किया जाता है।

— XNOR
स्रोत

यह पायथ में 6 बाइट्स है, और त्रुटि को दबा देता है:#\nJ|EJ

— 22

5

गणितज्ञ 38 बाइट्स

पैटर्न मिलान बार-बार बदलता ...a,0,...है...a,a...

#//.{b___,a_/;a!=0,0,e___}:>{b,a,a,e}&

— DavidC
स्रोत

5

मतलाब, 41 46 बाइट्स

यह निम्नलिखित अंतरों के साथ मेरे मूल उत्तर में प्रेरित है :

इसके बजाय तार्किक अनुक्रमण का उपयोग करें nonzeros।
साथ तुलना करने के बजाय डबल तार्किक निषेध 0।
संक्रमण को हटाया जा सकता है, क्योंकि आउटपुट स्वरूप लचीला है
एक मध्यवर्ती चर निकालना।

आइटम 4 के लिए टॉम कारपेंटर का धन्यवाद , और एक समारोह के बजाय एक कार्यक्रम का उपयोग करने के उनके सुझाव के लिए; इन दोनों ने मिलकर 5 बाइट्स में कमी की अनुमति दी।

x=input('');u=x(~~x);disp(u(cumsum(~~x)))

उदाहरण:

>> x=input('');u=x(~~x);disp(u(cumsum(~~x)))
[4 0 3 2 0 5 6 0]
     4     4     3     2     2     5     6     6

— लुइस मेंडो
स्रोत

आप एक बाइट को किसी प्रोग्राम में कनवर्ट करके बचा सकते हैं - x=input('')फ़ंक्शन डिक्लेरेशन के बजाय उपयोग करें , और बिट के disp(u(t)बजाय y=। इसके अलावा, आप tचर से छुटकारा पाने के लिए चार और बाइट्स बचा सकते हैं , x=input('');u=x(~~x);disp(u(cumsum(~~x)))41 के लिए उपज।

— टॉम कारपेंटर

@TomCarpenter बहुत बहुत धन्यवाद! संपादित

— लुइस मेंडू

मेरे पास मतलाब नहीं है, लेकिन @(x)x(~~x)(cumsum(~~x))ऑक्टेव में काम करता है।

— एलेफाल्फा

@alephalpha Matlab पुनरावृत्त अनुक्रमण की अनुमति नहीं देता है।

— एलेक्सर

5

गोल> <> , 8 बाइट्स

IE;:Z~:N

इनपुट और आउटपुट न्यूलाइन सेपरेटेड नंबर हैं।

स्पष्टीकरण:

I         push next integer to stack
 E;       halt if EOF
   :Z~    remove top stack element if 0
      :N  print top stack element while also keeping it on the stack
          wrap around code implicitly

इसे यहाँ ऑनलाइन आज़माएँ।

— randomra
स्रोत

5

जाप, 8 7 बाइट्स

N£U=XªU

बहुत साधारण। अल्पविराम द्वारा अलग किए गए इनपुट लेता है। इसे ऑनलाइन आज़माएं!

अपुष्ट और व्याख्या

N£    U=Xª U
NmXYZ{U=X||U

        // Implicit: N = input, U = first item
NmXYZ{  // Map each item X to:
U=Z||U  //  Set U to (X || U) and return.
        //  If X is non-zero, this sets U to X.
        //  Otherwise, this leaves U as the last non-zero we've encountered.
        // Implicit: output last expression

गैर-प्रतिस्पर्धी 4-बाइट संस्करण: ( åकमांड और !-ऑटो-फ़ंक्शन चुनौती के बाद जोड़ा गया)

Nå!ª

स्पष्टीकरण:

Nå!ª
Nå!||
NåXY{Y||X}

        // Implicit: N = input, U = first item
NåXY{   // Cumulatively reduce N; take each item Y and prev value X,
Y||X}   //  and return Y if it is non-zero; return X otherwise.
        // Implicit: output last expression

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

— ETHproductions
स्रोत

रुको, ªया, बजाय है º? है ºऔर किसी भी संयोग से?

— केयर्ड कॉइनरहाइडिंग

@cairdcoinheringaahing नोप, ºहै ((। यूनिकोड मान द्वारा उन्हें असाइन किया गया था क्योंकि मुझे उनकी आवश्यकता थी: पी ªएन डी और ºआर जीनियस है, हालांकि, मैं जाप 2.0 के लिए उपयोग कर सकता हूं ...

— ETHproductions

5

जावा, 78

int[]f(int[]a){for(int i=-1,b=i;++i<a.length;a[i]=b=a[i]==0?b:a[i]);return a;}

यहां हम केवल अंतिम गैर-शून्य का ट्रैक रखते हैं और जहां उपयुक्त हो वहां इसे बंद कर देते हैं। ऐसा करने का स्पष्ट तरीका लगता है।

— Geobits
स्रोत

5

प्रोलॉग (एसडब्ल्यूआई) , 54 बाइट्स

[X,0|T]+[X,X|Y]:-[X|T]+[X|Y].
[X|T]+[X|Y]:-T+Y.
[]+[].

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

व्याख्या

मैं वास्तव में इस जवाब से खुश हूं।

पहले हम कहते हैं कि खाली सूची खाली सूची का समाधान है:

[]+[].

फिर हम कहते हैं कि [X,X|Y]इसका समाधान है [X,0|T], यदि शेष समाधानों में से प्रत्येक की दूसरी प्रविष्टि को हटाकर।

[X,0|T]+[X,X|Y]:-[X|T]+[X|Y].

अंत में हम कहते हैं कि कोई भी चीज बची हुई है, यदि वे एक ही मूल्य से शुरू होती हैं और बाकी दोनों सूचियाँ एक-दूसरे से मेल खाती हैं तो यह मान्य है।

यदि वह स्पष्टीकरण आपके लिए काम नहीं कर रहा है तो हस्केल में अनुवादित कोड है:

g(a:0:x)=a:g(a:x)
g(a:x)=a:g x
g x=x

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

— गेहूं का जादूगर
स्रोत

बहुत संक्षिप्त! मुझे पसंद है कि कैसे कुछ कार्यात्मक और तर्क प्रोग्रामिंग भाषाएं आपको नियमों का ऐसा शाब्दिक अनुवाद करने की अनुमति देती हैं। इसे लिखने का यह एक स्वाभाविक तरीका है!

— thePlasmaRailgun

4

GolfScript, 10 बाइट्स

~{1$or}*]`

यह कार्यक्रम स्टड से इनपुट लेता है, एक गोल्फस्क्रिप्ट सरणी शाब्दिक (जैसे [1 0 2 0]) के रूप में, और उसी प्रारूप (जैसे [1 1 2 2]) में स्टडआउट के लिए इसका आउटपुट लिखता है ।

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

एक फ़ंक्शन (एक गोल्फस्क्रिप्ट सरणी लेना और वापस करना) तीन बाइट्स लंबा होगा, इसे ब्लॉक में लपेटने और इसे एक प्रतीक पर असाइन करने की आवश्यकता के कारण:

{[{1$or}*]}:f

बेशक, यदि केवल फ़ंक्शन बॉडी (यानी [{1$or}*]) को गिना जाता है, तो मैं वास्तव में स्टैंड-अलोन प्रोग्राम की तुलना में एक बाइट बचा सकता हूं।

— इल्मरी करोनें
स्रोत

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

— इल्मरी करोनें

4

मिंकोलंग 0.14 , 12 10 बाइट्स

$I?.nd?xdN

इसे यहाँ आज़माएँ। इनपुट प्रश्न में दिए जा सकते हैं, लेकिन बिना कोष्ठक के ।

व्याख्या

$I      Push the length of the input on the stack.
  ?.    If this is 0, stop. Otherwise, continue.

nd        Take number from input and duplicate it.
  ?x      If this number is 0, dump the top of stack.
    dN    Duplicate the top of stack and output as number

मिंकोलंग टॉरॉयडल है, इसलिए यह शुरुआत में चारों ओर घूमता है और तब तक चलता रहता है जब तक कि यह हिट नहीं .हो जाता और रुक जाता है।

— एलेंडिया स्ट्राटन
स्रोत

4

S, 7 चार्ट / 12 बाइट्स

ïⓜa=$⋎a

Try it here (Firefox only).

व्याख्या

        // implicit: ï = input array
ïⓜ     // map over input
  a=    // set a to:
    $   // (if element is truthy (not 0)) element itself
     ⋎a // else whatever a was set to before
        // implicit output

— मामा फन रोल
स्रोत

4

ओ , 31 बाइट्स

[[I',T%T/]{n#}d]{n.{:V}{;V}?}d]

इसके द्वारा अलग किए गए इनपुट को लेता है ,और उसी सूची को आउटपुट करता है []।

7,0,3,0,0,2,-50,0,0 => [7,7,3,3,3,2,-50,-50,-50]

स्पष्टीकरण:

[] परिणाम को सरणी में रखें
 [I ', T% T /] {n #} d] संख्याओं की सरणी में प्रारूप इनपुट
                {n। {: V} {, V};} d जीरो में भरें (नीचे देखें कि यह कैसे काम करता है)

17 बाइट्स

I~]{n.{:V}{;V}?}d

पोस्टफ़िक्स नोटेशन का उपयोग करके रिक्त स्थान द्वारा अलग किए गए नंबरों की सूची के रूप में इनपुट लेता है और केवल एक अंक हेक्साडेसिमल संख्याओं को संभाल सकता है। नकारात्मक के साथ उपसर्ग हैं _।

5 4 0 0 1 0 0 => 5 4 4 4 1 1 1
A 3 0 0 1 B 0 => 10 3 3 3 1 11 11
67* 0 0 78* 0 => 42 42 42 56 56
67*_ 4 3_ 0 0 => -42 4 -3 -3 -3

स्पष्टीकरण:

मैं ~] पूर्णांक सरणी में इनपुट डालता है
   {} d इनपुट में प्रत्येक संख्या के लिए
    । N {; वी} {: वी}? यदि संख्या 0 है, तो V धक्का दें
                  यदि नहीं, तो V को संख्या पर सेट करें

— अवस्था
स्रोत

आप दो बाइट्स के साथ बचा सकते हैं I~]{n.{:V}{;V}?}d। मुझे आश्चर्य है कि अगर dसिर्फ स्टैक पर मान डालना चाहिए n...

— kirbyfan64sos

क्या आप निश्चित हैं कि O इसे संभाल सकता है? मैं इसे पास नहीं कर सकता -42 को संतुष्ट करने के लिए "आपका आउटपुट आपके जमा करने की आवश्यकता के लिए एक स्वीकार्य इनपुट होना चाहिए"।

— मैनटवर्क

@manatwork मुझे अब एक बेहतर संस्करण मिला है जो इसके लिए काम करता है -42, लेकिन यह आउटपुट के चारों ओर कोष्ठक जोड़ता है।

— चरण

4

आर, ३ ९ ३ by ३३ बाइट्स

function(x)zoo::na.locf(x*(x|NA))

यह एक अनाम फ़ंक्शन है जो वेक्टर को स्वीकार करता है और एक वेक्टर लौटाता है। इसके लिए zooपैकेज स्थापित करना आवश्यक है। ध्यान दें कि zooइसे सीधे नामस्थान से संलग्न करने की आवश्यकता नहीं है क्योंकि हम इसे सीधे संदर्भित कर रहे हैं।

आंकड़ों की दुनिया में इस ऑपरेशन का नाम एलओसीएफ इंप्यूटेशन है, जहां एलओसीएफ का मतलब लास्ट ऑब्जर्वेशन कैरी फॉरवर्ड है। आर में इसे पूरा करने के लिए, हम पैकेज na.locfसे उपयोग कर सकते हैं zoo, जो NAअंतिम ज्ञात गैर- NAमूल्य के साथ मूल्यों को बदलता है । हमें बस NAपहले के साथ इनपुट में शून्य को बदलना होगा ।

ऐसा करने के लिए, हम उपयोग करते हैं x|NA, जो TRUEतब होगा जब x != 0और NAअन्यथा। अगर हम गुणा इस से x, TRUEतत्वों की इसी तत्वों ने ले ली है xऔर NAरहने NA, जिससे सभी शून्य की जगह। यह तब पारित किया जाता है zoo::na.locfजो हमें वही देता है जो हम चाहते हैं।

Flodel के लिए धन्यवाद 4 बाइट्स सहेजे गए!

— एलेक्स ए।
स्रोत

4

जंग, 100 बाइट्स

fn f(i:&[i64])->Vec<i64>{let(mut o,mut l)=(i.to_vec(),0);
for x in&mut o{if *x==0{*x=l}else{l=*x}};o}

इस चुनौती से लड़कर, सोचा कि मैं इसे अपनी पसंदीदा भाषा में आज़माऊँगा। [T]::windows_mut()पहले पता लगाने की कोशिश की , यह पता लगाने से पहले कि यह मौजूद नहीं है । और यह वास्तव में इस से लंबा हो सकता है। वैसे भी, यह पता चला है कि गोल्फ की जंग बहुत बदसूरत है और बहुत प्रतिस्पर्धात्मक नहीं है (विशेष रूप से उन सभी goshdarned गूढ़ व्यक्ति के साथ!) ¹

नई लाइन बायटेकाउंट में शामिल नहीं है; यह केवल इतना है कि आपको बग़ल में स्क्रॉल करने की आवश्यकता नहीं है। यह कोड का अर्थ नहीं बदलता है।

Ungolfed:

fn cover_zeroes(input: &[i64]) -> Vec<i64> {
    let mut output = input.to_vec();
    let mut last_nonzero = 0;
    for item in &mut output {
        if *item == 0 {
            *item = last_nonzero;
        }
        else {
            last_nonzero = *item;
        }
    }
    output
}

_{^{[१] कम से कम यह जावा जितना बुरा नहीं है।}}

— ब्लैकलाइट चमक रहा है
स्रोत

7

" कम से कम यह जावा जितना बुरा नहीं है "? अहम ... ;)

— भूतकाल

1

@Geobits ओह, ठीक है। मैं आप पर भरोसा कर रहा था कि public static void mainबॉयलरप्लेट की जरूरत है ...

— ब्लैकलाइट शाइनिंग

3

मिल्की वे 1.2.1 , 33 बाइट्स

:y;=<:&{~<?{0b_^;:3≤_;}1-}^<Ω!

यह मानता है कि पूर्णांकों की सूची केवल स्टैक पर है।

व्याख्या

:    : :           :              # duplicate the TOS
 y                                # push the length of the TOS
  ;               ;    ;          # swap the TOS and STOS
   =                              # dump a list to the stack
    < <    <                 <    # rotate the stack leftward
        &{~                }      # while loop
            ?{  _     _ }         # if-else statements
              0     3    1        # push an integer
               b                  # == on the TOS and STOS
                 ^          ^     # pop the TOS without output
                     ≤            # rotate the top N stack elements leftward
                          -       # subtract the TOS from the STOS
                              Ω   # push a list made of the top N stack elements
                               !  # output the TOS

— Zach गेट्स
स्रोत

मुझे पूरा यकीन है कि टीओएस और एसटीओएस का मतलब टॉप ऑफ स्टैक और सेकंड-टू-टॉप ऑफ स्टैक है, क्या यह सही है?

— एडिसन क्रम्प

Yep @FlagAsSpam

— Zach गेट्स

3

जूलिया, 33 बाइट्स

g(x,a=0)=[(i!=0&&(a=i);a)for i=x]

यह एक फ़ंक्शन है gजो किसी सरणी को स्वीकार करता है और एक सरणी देता है। हम a0. पर एक अस्थायी चर शुरू करते iहैं, इनपुट के प्रत्येक तत्व के लिए, यदि i0 नहीं है तो हम असाइन aकरते हैं i। यदि i0 है, aतो उस पुनरावृत्ति पर परिवर्तित नहीं होता है। हम aआउटपुट एरे में उस स्थिति में मान के रूप में उपयोग करते हैं ।

— एलेक्स ए।
स्रोत

3

पर्ल 6 , 21 बाइट्स

*.map: {$_=($^a||$_)}

उपयोग:

# store the Whatever lambda as a subroutine
# just so that we don't have to repeat it
my &code = *.map: {$_=($^a||$_)}

say code [1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9];
# (1 1 2 2 7 7 7 7 5 5 5 5 9)

say [-1, 0, 5, 0, 0, -7].&code;
# (-1 -1 5 5 5 -7)

say ([1, 0, 0, 0, 0, 0],[-1, 0, 5, 0, 0, -7]).map: &code;
# ((1 1 1 1 1 1) (-1 -1 5 5 5 -7))

— ब्रैड गिल्बर्ट b2gills
स्रोत

3

आर, 36 बाइट्स

function(x)x[cummax(seq(a=x)*(!!x))]

आइए देखें कि यह कैसे काम करता है x=

c(1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9)

उदहारण के लिए। यहाँ, !!xतार्किक (सत्य / असत्य) वेक्टर होगा:

c(T, F, T, F, T, T, T, F, T, F, F, F, T)

इसके अलावा, seq(a=x)जब तक सूचकांकों का एक सदिश देता है x:

c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

हम दोनों को गुणा करते हैं:

c(1, 0, 3, 0, 5, 6, 7, 0, 9, 0, 0, 0, 13)

हम संचयी अधिकतम लेते हैं:

c(1, 1, 3, 3, 5, 6, 7, 7, 9, 9, 9, 9, 13)

अंत में, हम उस अंतिम वेक्टर का उपयोग सूचकांकों के रूप में करते हैं x:

c(1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9)

— flodel
स्रोत

3

सीजेएम, 11 बाइट्स

q~{1$e|}*]p

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

यह काम किस प्रकार करता है

q~             Read and evaluate all input.
  {    }*      Fold; for each element but the first:
   1$e|          Copy the previous element and take their logical OR.
         ]p   Wrap all results in an array and print it.

— डेनिस
स्रोत

3

पॉवर्सशैल, 32 बाइट्स

param($x)$x|%{($t=($_,$t)[!$_])}

$x|%{...}स्क्रिप्ट प्रत्येक तत्व के लिए ब्लॉक करता है $x। ($_,$t)वर्तमान तत्व का एक सरणी है $t, और [!$_]इसका मतलब है कि हम !$_सरणी में अनुक्रमित करने के लिए उपयोग करते हैं। 0गैर-शून्य तत्वों के लिए सूचकांक (गलत) होगा और 1(सत्य) जब वर्तमान तत्व शून्य $tहोगा , तो या तो वर्तमान तत्व होगा या $t। कोष्ठक असाइनमेंट अभिव्यक्ति को घेरता है इसलिए इसका मान उत्सर्जित होता है। परांठे के बिना यह सिर्फ एक "शांत" असाइनमेंट होगा $t।

— डैंको डर्बीक
स्रोत

@ टिम्मीड, आप सही हैं, बिल्कुल। मैंने जोड़ा है param($x)जो इसे एक कार्यक्रम में बदल देता है। आउटपुट पूर्णांकों का एक संग्रह है जिसे आप प्रोग्राम के पैरामीटर के रूप में सबमिट कर सकते हैं, उदाहरण के लिए $a = .\program.ps1 1,2,3,4,0,0,5और फिर .\program.ps1 $aअपेक्षित रूप से काम करता है।

— डैंको डर्बिएक

$args|%{($p=($_,$p)[!$_])}- $ $ का उपयोग करके 26 बाइट्स।

— TessellatingHeckler

3

जाप , 3 बाइट्स

å!ª

कोशिश करो

å!ª     :Implicit input of array
å       :Cumulatively reduce
 !      :Flip the arguments
  ª     :Logical OR

— झबरा
स्रोत

एक सूची में शून्य को कवर करें

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

अजगर, 6 बाइट्स

जेली , गैर-प्रतिस्पर्धात्मक

यह काम किस प्रकार करता है

रूबी, 25 बाइट्स

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

जे, 8 बाइट्स

व्याख्या

पाल, 8

जावास्क्रिप्ट ईएस 6, 19 बाइट्स

रेटिना , 15 बाइट्स

डायलॉग एपीएल, 12 10 9 बाइट्स

पायथ, 8 बाइट्स

पायथन 2, 29 बाइट्स

गणितज्ञ 38 बाइट्स

मतलाब, 41 46 बाइट्स

गोल> <> , 8 बाइट्स

जाप, 8 7 बाइट्स

अपुष्ट और व्याख्या

जावा, 78

प्रोलॉग (एसडब्ल्यूआई) , 54 बाइट्स

व्याख्या

GolfScript, 10 बाइट्स

मिंकोलंग 0.14 , 12 10 बाइट्स

व्याख्या

S, 7 चार्ट / 12 बाइट्स

व्याख्या

ओ , 31 बाइट्स

17 बाइट्स

आर, ३ ९ ३ by ३३ बाइट्स

जंग, 100 बाइट्स

मिल्की वे 1.2.1 , 33 बाइट्स

व्याख्या

जूलिया, 33 बाइट्स

पर्ल 6 , 21 बाइट्स

आर, 36 बाइट्स

सीजेएम, 11 बाइट्स

यह काम किस प्रकार करता है

पॉवर्सशैल, 32 बाइट्स

जाप , 3 बाइट्स