अधिक से अधिक संख्या के साथ बढ़ते क्रम में भरें

29

संख्याओं की एक सूची को नीरस रूप से वृद्धि कहा जाता है (या nondecreasing) प्रत्येक तत्व इसके पहले के तत्व से अधिक या बराबर है।

उदाहरण के लिए, 1, 1, 2, 4, 5, 5, 5, 8, 10, 11, 14, 14एकरसता बढ़ रही है।

सकारात्मक पूर्णांकों की एक नीरस रूप से बढ़ती हुई सूची को देखते हुए, जिनके द्वारा निरूपित रिक्त स्थानों की एक मनमानी संख्या होती है ?, रिक्त स्थानों को सकारात्मक पूर्णांक के साथ भरें जैसे कि संभव के रूप में कई अद्वितीय पूर्णांक सूची में मौजूद हैं, फिर भी यह नीरस रूप से बढ़ रहा है।

इसे पूरा करने के कई तरीके हो सकते हैं। कोई भी मान्य है।

परिणामी सूची को आउटपुट करें।

उदाहरण के लिए , यदि इनपुट है

?, 1, ?, 1, 2, ?, 4, 5, 5, 5, ?, ?, ?, ?, 8, 10, 11, ?, 14, 14, ?, ?

यह गारंटी दी जाती है कि रिक्त स्थानों के बिना सूची नीरस रूप से बढ़ती जाएगी

1, 1, 2, 4, 5, 5, 5, 8, 10, 11, 14, 14

और आपका कार्य प्रत्येक के ?लिए सकारात्मक पूर्णांकों को निर्दिष्ट करना है ताकि सूची में अलग-अलग पूर्णांकों की संख्या को अधिकतम किया जा सके, जबकि इसे गैरकानूनी रखा जा सके।

एक असाइनमेंट जो मान्य नहीं है

1, 1, 1, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 5, 8, 10, 11, 14, 14, 14, 14, 14

क्योंकि, जब यह nondecreasing है, तो यह केवल इनपुट की तुलना में एक अधिक अद्वितीय पूर्णांक है, अर्थात् 3।

इस उदाहरण में छह अद्वितीय धनात्मक पूर्णांक सम्मिलित करना संभव है और सूची को निरर्थक रखना है।
कुछ संभावित तरीके हैं:

1, 1, 1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 8, 8, 10, 11, 12, 14, 14, 15, 16

1, 1, 1, 1, 2, 3, 4, 5, 5, 5, 5, 6, 6, 7, 8, 10, 11, 13, 14, 14, 20, 200

या तो इनमें से (और कई अन्य) वैध आउटपुट होंगे।

सभी खाली स्थानों को भरना होगा।

पूर्णांक पर कोई ऊपरी सीमा नहीं है जिसे डाला जा सकता है। यदि वैज्ञानिक अंकन में बहुत बड़े पूर्णांक छपे हों तो यह ठीक है।

शून्य एक सकारात्मक पूर्णांक नहीं है और इसे कभी नहीं डाला जाना चाहिए।

के स्थान में ?आप किसी भी एक समान मान है कि एक सकारात्मक पूर्णांक नहीं है, इस तरह के रूप का उपयोग कर सकते 0, -1, null, False, या ""।

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

और ज्यादा उदाहरण

[input]
[one possible output] (a "*" means it is the only possible output)

2, 4, 10
2, 4, 10 *

1, ?, 3
1, 2, 3 *

1, ?, 4
1, 2, 4

{empty list}
{empty list} *

8
8 *

?
42

?, ?, ?
271, 828, 1729

?, 1
1, 1 *

?, 2
1, 2 *

?, 3
1, 3

45, ?
45, 314159265359

1, ?, ?, ?, 1
1, 1, 1, 1, 1 *

3, ?, ?, ?, ?, 30
3, 7, 10, 23, 29, 30 

1, ?, 2, ?, 3, ?, 4
1, 1, 2, 3, 3, 3, 4

1, ?, 3, ?, 5, ?, 7
1, 2, 3, 4, 5, 6, 7 *

1, ?, 3, ?, 5, ?, ?, 7
1, 2, 3, 4, 5, 6, 7, 7

1, ?, ?, ?, ?, 2, ?, ?, ?, ?, 4, ?, 4, ?, ?, 6
1, 1, 1, 1, 1, 2, 3, 4, 4, 4, 4, 4, 4, 5, 6, 6

98, ?, ?, ?, 102, ?, 104
98, 99, 100, 101, 102, 103, 104 *
code-golf  number  arithmetic  integer 
— केल्विन के शौक
स्रोत
संभवत: सत्यापन के लिए एक सख्त इनपुट, आउटपुट जोड़ी वाली समस्या को वाक्यांश करने का एक बेहतर तरीका होगा, "अनुक्रम में विभिन्न संख्याओं की उच्चतम संभव संख्या क्या होगी"। इस तरह से सभी उत्तर समान संख्या में आउटपुट होंगे और परीक्षण के मामलों का मूल्यांकन बहुत आसान बना देते हैं
— क्रंचर
@StewieGriffin आप मान सकते हैं कि सूची मान और लंबाई हमेशा की तरह अधिकतम अधिकतम सीमा से कम है। मेरा केवल यही मतलब था कि अगर आपके एल्गोरिथ्म में काम हो तो अंत में बहुत बड़े पूर्णांक सम्मिलित करना ठीक है।
— केल्विन के शौक

जवाबों:

11

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

fएक सूची लेता है और 0 का प्रतिनिधित्व करने के साथ एक सूची देता है ?।

f=scanr1 min.tail.scanl(#)0
m#0=m+1
_#n=n

मूल रूप से, बाईं ओर से पहली स्कैन सूची, पिछले तत्व की तुलना में एक से अधिक (या शुरुआत में 0) की जगह; फिर सही को कम करने से बड़े तत्वों को अपने दाईं ओर बराबर करने के लिए स्कैन करें।

इसे ऑनलाइन आज़माएं! ( ?एस बदलने के लिए आवरण के साथ ।)

— अर्जन जोहान्सन
स्रोत
4

मैथेमेटिका, 84 बाइट्स

Rest[{0,##}&@@#//.{a___,b_,,c___}:>{a,b,b+1,c}//.{a___,b_,c_,d___}/;b>c:>{a,c,c,d}]&

शुद्ध कार्य को तर्क के रूप में एक सूची लेते हैं, जहां खाली स्थानों को Null(के रूप में {1, Null, Null, 2, Null}) से चिह्नित किया जाता है या पूरी तरह से हटा दिया जाता है (जैसा कि {1, , , 2, }), और एक उपयुक्त सूची (इस मामले में {1, 2, 2, 2, 3}) लौटाता है ।

यह बताता है कि मैं asrjan जोहानसन के हास्केल उत्तर में एक ही एल्गोरिथ्म का उपयोग कर रहा हूं : पहले हर Nullएक को उसके बाईं ओर की संख्या से अधिक ( //.{a___,b_,,c___}:>{a,b,b+1,c}) से बदलें, फिर किसी भी बहुत बड़ी संख्या को उसके दाईं ओर ( //.{a___,b_,c_,d___}/;b>c:>{a,c,c,d}) से बदलें । संभव के साथ सौदा करने के लिए Nullसूची की शुरुआत में है, हम एक prepending द्वारा शुरू 0( {0,##}&@@#), एल्गोरिथ्म कर रही है, तो प्रारंभिक को हटाने 0( Rest)।

हाँ, मैं चुना है Nullके बजाय Xया सचमुच कोड में (एक है कि अन्यथा की अल्पविराम के बीच होगी एक बाइट को बचाने के लिए ऐसा ही कुछ b_,,c___)।

— ग्रेग मार्टिन
स्रोत
हम्म, 1 आप कह रहे हैं? मैं एक 0 का उपयोग करता था, जैसी चीजों के कारण ?, 2। मुझे संदेह है कि आप 2, 2सही के बजाय उत्पादन करेंगे 1, 2।
— अर्जन जोहान्सन
बहुत बढ़िया बात! सौभाग्य से फिक्स आसान है।
— ग्रेग मार्टिन
3

सी 160

यह कभी नहीं जीतेगा लेकिन:

#define p(x)printf("%d ",x);
i=1,l=0,m=0,n;main(c,v)char**v;{for(;i<c;i++)if(*v[i]==63)m++;else{for(n=atoi(v[i]);m>0;m--)p(l<n?++l:n)p(l=n)}for(;m>0;m--)p(++l)}

यह कमांड लाइन तर्कों से सूची लेता है।

— जेरी यिर्मयाह
स्रोत
— छत
3

05AB1E , 31 23 13 बाइट्स

ग्रेमी की बदौलत 10 बाइट्स बचीं

ε®X:D>U].sR€ß

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

व्याख्या

ε      ]       # apply to each number in input
 ®X:           # replace -1 with X (initially 1)
    D>U        # store current_number+1 in X
        .s     # get a list of suffixes
          R    # reverse
           ۧ  # take the minimum of each
— Emigna
स्रोत
यह केवल आउटपुट का हिस्सा क्यों प्रिंट करता है? आपके TIO उदाहरण में पहले 1 गायब है।
— घातक
मुझे पता है कि यह एक समय हो गया है, और यह शायद कुछ और गोल्फ हो सकता है, लेकिन कुछ आसान गोल्फ के साथ -3 बाइट्स: दोनों }}को ]2 बाइट्स बचाने के लिए हो सकता है; और एक अतिरिक्त बाइट को बचाने के लिए õ-)Rकिया जा सकता )˜Rहै।
— केविन क्रूज़सेन
2
@ केविनक्रूजसेन: वास्तव में यह हो सकता है :)
— एमिग्ना
1
यह अभी भी कर सकते हैं! 16 , 15 , 13 ।
— ग्रैमी
@Grimy: वाह, धन्यवाद! यह प्रत्यय चाल वास्तव में स्मार्ट था!
— एमिग्ना
2

पिप , 25 23 21 बाइट्स

Y{Y+a|y+1}MgW PMNyPOy

इनपुट को कई अंतरिक्ष-पृथक कमांड-लाइन तर्कों के रूप में लेता है। परिणाम सूची को प्रति पंक्ति एक नंबर पर आउटपुट करता है। इसे ऑनलाइन आज़माएं! (मैंने कई कमांड-लाइन आर्ग्स चीज़ों को ठग लिया है क्योंकि यह TIO पर 25 तर्कों को जोड़ने के लिए एक दर्द होगा, लेकिन यह विज्ञापित के रूप में भी काम करता है।)

व्याख्या

हम दो पास में आगे बढ़ते हैं। सबसे पहले, हम ?इनपुट के प्रत्येक रन को सूची में पिछले नंबर से शुरू करते हुए और हर बार एक क्रम से बढ़ते हुए बदलते हैं :

? 1 ? 1 2 ? 4 5 5 5 ? ? ? ? 8 10 11 ?  14 14 ?  ?
1 1 2 1 2 3 4 5 5 5 6 7 8 9 8 10 11 12 14 14 15 16

फिर हम फिर से लूप करते हैं; प्रत्येक संख्या के लिए, हम इसके न्यूनतम और सभी नंबरों को इसके दाईं ओर प्रिंट करते हैं। यह एकरसता को बनाए रखने के लिए बहुत अधिक संख्याओं को नीचे लाता है।

                      y is initially "", which is 0 in numeric contexts
                      Stage 1:
 {       }Mg           Map this function to list of cmdline args g:
   +a                  Convert item to number: 0 (falsey) if ?, else nonzero (truthy)
     |                 Logical OR
      y+1              Previous number +1
  Y                    Yank that value into y (it is also returned for the map operation)
Y                      After the map operation, yank the whole result list into y
                      Stage 2:
            W          While loop, with the condition:
               MNy      min(y)
              P         printed (when y is empty, MN returns nil, which produces no output)
                  POy  Inside the loop, pop the leftmost item from y
— DLosc
स्रोत
2

न्यूमपी के साथ अजगर 2, 163 बाइट्स

@Wythagoras की बदौलत 8 बाइट्स बचाए

शून्य खाली स्थानों को चिह्नित करता था

import numpy
l=[1]+input()
z=numpy.nonzero(l)[0]
def f(a,b):
 while b-a-1:a+=1;l[a]=l[a-1]+1;l[a]=min(l[a],l[b])
i=1
while len(z)-i:f(z[i-1],z[i]);i+=1
print l[1:]

टिप्पणियों के साथ अधिक पठनीय:

import numpy
l=[1]+input()           # add 1 to the begining of list to handle leading zeros
z=numpy.nonzero(l)[0]   # get indices of all non-zero values
def f(a,b):             # function to fill gap, between indices a and b
    while b-a-1:
        a+=1
        l[a]=l[a-1]+1   # set each element value 1 larger than previous element
        l[a]=min(l[a],l[b])   # caps it by value at index b
i=1
while len(z)-i:       
    f(z[i-1],z[i])      # call function for every gap
    i+=1
print l[1:]             # print result, excluding first element, added at the begining
— मृत पोसुम
स्रोत
1
कुछ सुधार: if l[a]>l[b]:l[a]=l[b]हो सकते हैं l[a]=min(l[a],l[b])और फिर इससे पहले की लाइन में हो सकते हैं। इसके अलावा, इसका मतलब है कि पूरी लाइन के बाद रखा जा सकता है while। और मुझे लगता है l=input()और l=[1]+lहो सकता है l=[1]+input()(इसके अलावा सामान्य रूप में,: आप खरोज के दो स्तर का उपयोग करते हैं, तो आप एक जगह और एक टैब के बजाय एक अंतरिक्ष और अजगर 2 में दो रिक्त स्थान का उपयोग कर सकते हैं (देखें codegolf.stackexchange.com/a/58 ) )
— विथागोरस
1
इसके अलावा, अंतिम पंक्ति के बगल में len(z)-i:f(z[i-1],z[i]);i+=1i = 1 से शुरू करते समय हो सकता है ।
— विथागोरस
@wythagoras धन्यवाद, अच्छी सलाह। मैंने इसे कोड में जोड़ा है
— डेड पॉसम
अच्छा लगा, लेकिन यह केवल 163 बाइट्स है।
— विथगोरस
@wythagoras ओह, मैं बाइट काउंट अपडेट करना भूल गया था
— डेड पॉसम
1

PHP, 95 77 71 69 68 बाइट्स

for($p=1;$n=$argv[++$i];)echo$p=$n>0?$n:++$p-in_array($p,$argv)," ";

कमांड लाइन तर्कों से इनपुट लेता है, अंतरिक्ष से अलग की गई सूची प्रिंट करता है। के साथ भागो -nr।

टूट - फूट

for($p=1;$n=$argv[++$i];)   # loop through arguments
    echo$p=                     # print and copy to $p:
    $n>0                            # if positive number
        ?$n                             # then argument
        :++$p                           # else $p+1 ...
            -in_array($p,$argv)         # ... -1 if $p+1 is in input values
    ," ";                       # print space

$nकिसी भी स्ट्रिंग लेकिन रिक्त स्ट्रिंग और के लिए truthy है "0"।
$n>0सकारात्मक संख्याओं के लिए सत्य है - और उनसे युक्त तार।

— टाइटस
स्रोत
1

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

{my $p;~S:g/(\d+' ')?<(('?')+%%' ')>(\d*)/{flat(+($0||$p)^..(+$2||*),(+$2 xx*,($p=$2)))[^+@1]} /}

इनपुट या तो मानों की एक सूची है, या एक अंतरिक्ष अलग स्ट्रिंग है, जहां ?मूल्यों को प्रतिस्थापित करने के लिए खड़े होने के लिए उपयोग किया जाता है।

आउटपुट एक अंतरिक्ष अलग स्ट्रिंग है जो एक अनुगामी स्थान के साथ है।

कोशिश करो

विस्तारित:

{                       # bare block lambda with implicit parameter ｢$_｣

    my $p;              # holds the previous value of ｢$2｣ in cases where
                        # a number is sandwiched between two replacements

    ~                   # stringify (may not be necessary)
    S                   # replace
    :global
    /
        ( \d+ ' ' )?    # a number followed by a space optionally ($0)

        <(              # start of replacement

          ( '?' )+      # a list of question marks
          %%            # separated by (with optional trailing)
          ' '           # a space

        )>              # end of replacement

        (\d*)           # an optional number ($2)

    /{                  # replace with the result of:

        flat(

          +( $0 || $p ) # previous value or 0
          ^..           # a range that excludes the first value
          ( +$2 || * ), # the next value, or a Whatever star

          (
            +$2 xx *,   # the next value repeated endlessly

            ( $p = $2 ) # store the next value in ｢$p｣
          )

        )[ ^ +@1 ]      # get as many values as there are replacement chars
    } /                 # add a space afterwards
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
मैं पर्ल 6 को नहीं जानता, लेकिन पर्ल 5 में आप बाइट दाढ़ी बनाने के $"बजाय इस्तेमाल कर सकते हैं ' '। क्या वह यहाँ काम करता है?
— msh210
@ msh210 लगभग उन सभी चर या तो चले गए हैं, या उनके नाम लंबे हैं। केवल एक के बारे में जो अभी भी मौजूद है और इसका एक ही उद्देश्य है $!। ( $/मौजूद है, लेकिन $1→ $/[1]और $<a>→ के लिए प्रयोग किया जाता है $/{ qw< a > })
— ब्रैड गिल्बर्ट b2gills
1

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

a=>a.map(e=>a=e||-~a).reduceRight((r,l)=>[r[0]<l?r[0]:l,...r],[])

क्योंकि मैं उपयोग करना चाहता था reduceRight। स्पष्टीकरण: mapप्रत्येक मिथ्या मान को पिछले मान से अधिक के साथ बदल देता है, फिर reduceRightअंत से यह सुनिश्चित करता है कि कोई भी मान निम्न मान से अधिक न हो।

— नील
स्रोत
1

क्यू, 63 बाइट्स

{1_(|){if[y>min x;y-:1];x,y}/[(|){if[y=0;y:1+-1#x];x,y}/[0,x]]}

मूल रूप से Hrjan जोहान्सन हास्केल जवाब के रूप में एक ही एल्गोरिथ्म ।

  • मान लेता है? = 0।
  • के मामले में सरणी की शुरुआत में एक 0 सम्मिलित करता है? प्रारंभ में।
  • 1 + पिछले तत्व के साथ 0 की जगह सरणी स्कैन करता है।
  • सरणी को उलट देता है और फिर से स्कैन करता है, पिछले तत्व से अधिक तत्वों को प्रतिस्थापित करता है।
  • पहले तत्व को उल्टा और काटता है (शुरुआत से जोड़ा गया 0)।

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

— डैनियल प्लेनव्यू
स्रोत
अच्छा जवाब, साइट पर आपका स्वागत है! :)
— DJMcMayhem
1

टीआई-बेसिक (TI-84 Plus CE), 81 बाइट्स

not(L1(1))+L1(1→L1(1
For(X,2,dim(L1
If not(L1(X
1+L1(X-1→L1(X
End
For(X,dim(L1)-1,1,-1
If L1(X)>L1(X+1
L1(X+1→L1(X
End
L1

अर्जन जोहान्सन के हास्केल का एक सरल बंदरगाह टीआई-बेसिक का जवाब है। शून्य मान के रूप में 0 का उपयोग करता है। L 1 से इनपुट लेता है ।

स्पष्टीकरण:

not(L1(1))+L1(1→L1(1 # if it starts with 0, change it to a 1
For(X,2,dim(L1     # starting at element 2:
If not(L1(X              # if the element is zero
1+L1(X-1→L1(X            # change the element to one plus the previous element
End
For(X,dim(L1)-1,1,-1 # starting at the second-last element and working backwards
If L1(X)>L1(X+1           # if the element is greater than the next
L1(X+1→L1(X               # set it equal to the next
End
L1                   # implicitly return
— pizzapants184
स्रोत
1

जावा 8, 199 164 बाइट्स

a->{for(int l=a.length,n,j,x,i=0;i<l;)if(a[i++]<1){for(n=j=i;j<l;j++)if(a[j]>0){n=j;j=l;}for(j=i-3;++j<n-1;)if(j<l)a[j+1]=j<0?1:a[j]+(l==n||a[n]>a[j]|a[n]<1?1:0);}}

बाइट्स को बचाने के लिए एक नया वापस करने के बजाय इनपुट-सरणी को संशोधित करता है।
के 0बजाय का उपयोग करता है ?।

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

स्पष्टीकरण:

a->{                      // Method with integer-array parameter and no return-type
  for(int l=a.length,     //  Length of the input-array
      n,j,x,              //  Temp integers
      i=0;i<l;)           //  Loop `i` over the input-array, in the range [0, length):
    if(a[i++]<1){         //   If the `i`'th number of the array is 0:
                          //   (And increase `i` to the next cell with `i++`)
      for(n=j=i;          //    Set both `n` and `j` to (the new) `i`
          j<l;j++)        //    Loop `j` in the range [`i`, length):
        if(a[j]>0){       //     If the `j`'th number of the array is not 0:
          n=j;            //      Set `n` to `j`
          j=l;}           //      And set `j` to the length to stop the loop
                          //    (`n` is now set to the index of the first non-0 number 
                          //     after the `i-1`'th number 0)
      for(j=i-3;++j<n-1;) //    Loop `j` in the range (`i`-3, `n-1`):
        if(j<l)           //     If `j` is still within bounds (smaller than the length)
          a[j+1]=         //      Set the `j+1`'th position to:
            j<0?          //       If `j` is a 'position' before the first number
             1            //        Set the first cell of the array to 1
            :             //       Else:
             a[j]+        //        Set it to the `j`'th number, plus:
              (l==n       //        If `n` is out of bounds bounds (length or larger)
               ||a[n]>a[j]//        Or the `n`'th number is larger than the `j`'th number
               |a[n]<1?   //        Or the `n`'th number is a 0
                1         //         Add 1
               :          //        Else:
                0);}}     //         Leave it unchanged by adding 0
— केविन क्रूज़सेन
स्रोत
0

पायथन 2 , 144 124 119 बाइट्स

l=input()
for n in range(len(l)):a=max(l[:n]+[0]);b=filter(abs,l[n:]);b=len(b)and b[0]or-~a;l[n]=l[n]or a+(b>a)
print l

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

के 0बजाय का उपयोग करता है?

— OVS
स्रोत
के b=filter(abs,l[n:])बराबर नहीं है b=l[n:] ?
— मृत पोसुम
@DeadPossum फ़िल्टर (abs ... फ़िल्टर सभी 0
— ovs
ओह, जो शून्य को हटाता है, मैं इसे प्राप्त करता हूं
— डेड पॉसम
0

जावास्क्रिप्ट (ईएस 6), 59

इनपुट के रूप में पूर्णांक सरणी के साथ एक फ़ंक्शन। खाली स्थानों के साथ चिह्नित हैं0

a=>a.map((v,i)=>v?w=v:(a.slice(i).find(x=>x)<=w?w:++w),w=0)

परीक्षा

var F=
a=>a.map((v,i)=>v?w=v:(a.slice(i).find(x=>x)<=w?w:++w),w=0)

;[[2, 4, 10]
,[1, 0, 3]
,[1, 0, 4]
,[]
,[8]
,[0]
,[0, 0, 0]
,[0, 1]
,[0, 2]
,[0, 3]
,[45, 0]
,[1, 0, 0, 0, 1]
,[3, 0, 0, 0, 0, 30]
,[1, 0, 2, 0, 3, 0, 4]
,[1, 0, 3, 0, 5, 0, 7]
,[1, 0, 3, 0, 5, 0, 0, 7]
,[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 4, 0, 4, 0, 0, 6]
,[98, 0, 0, 0, 102, 0, 104]]
.forEach(a=>{
  console.log(a+'\n'+F(a))
})
स्निपेट का विस्तार करें

— edc65
स्रोत
0

सी # (.NET कोर) , 182 बाइट्स

अर्जन जोहानसन जैसी ही रणनीति का उपयोग करना।

अज्ञात संस्करण को चिह्नित करने के लिए इनपुट सूची में 0 का उपयोग करता है।

l=>{if(l[0]<1)l[0]=1;int j;for(j=0;j<l.Length;j++)l[j]=l[j]==0?l[j-1]+1:l[j];for(j=l.Length-2;j>=0;j--)l[j]=l[j]>l[j+1]?l[j+1]:l[j];foreach(var m in l) System.Console.Write(m+" ");};

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

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