24

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

यह मेंढक आगे और पीछे कूदना पसंद करता है: आगे कूदने के बाद, वह हमेशा पीछे की ओर कूदता है , और इसके विपरीत।

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

उदाहरण के लिए, मान लें कि आप उत्तीर्ण हैं [2,3,6,8,2]:

हमारा मेंढक 2 लिली पैड को आगे कूदकर शुरू होता है:

_2

फिर 3 लिली पैड वापस:

3__2

फिर 6 लिली पैड आगे:

3__2__6

8 वापस:

8_3__2__6

फिर अंत में, 2 लिली पैड आगे (नोटिस कैसे 2 ओवरराइट करता है 3):

8_2__2__6

अधिक स्पष्ट होने के लिए: आपका इनपुट संख्याओं की एक सरणी है S, आपको S[K]स्थिति में आउटपुट की आवश्यकता है S[K] - S[K-1] + S[K-2] - S[K-3]...।

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

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

5                   ____5
2,2                 2_2
4,3,2,1             3124
5,3,2,1             _3125
2,3,6,8,2           8_2__2__6
10,3,12,4,1,12,16   ___12__3__10____41__1216
100,4,7,2,2         _______________________________________________________________________________________________4___1002_2

यह एक कोड-गोल्फ है , इसलिए इसे यथासंभव कम वर्णों में उत्तर दें!

code-golf string

— नाथन मेरिल
स्रोत

13

मुझे आश्चर्य है कि किसने नंबरफाइल देखा?

— ओकेक्स

3

तो हर नंबरफिल्म वीडियो के लिए फिर एक चुनौती होने वाली है ...

— घातक

5

Related :-P

— लुइस मेंडो

5

@ जानलेवा मैं इसके साथ कुछ भी गलत नहीं देखता।

— orlp

1

इसके अलावा संबंधित ;-)

— अर्नुलड

9

MATL , 35 34 बाइट्स

1 बाइट बचाने के लिए @Emigna को धन्यवाद !

32Oittn:oEq*Yst1hX<-Q(Vh' 0'95ZtXz

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

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

अपना कोड गोल्फ, अपने स्पष्टीकरण नहीं!

निम्न [2,3,6,8,2]उदाहरण के रूप में इनपुट का उपयोग करता है । वास्तविक कोड में मध्यवर्ती परिणाम देखने के लिए, आप %उस बिंदु पर प्रोग्राम को रोकने और स्टैक सामग्री को देखने के लिए (टिप्पणी प्रतीक) सम्मिलित कर सकते हैं। उदाहरण के लिए, यह स्टेटमेंट Ys(संचयी योग) के बाद स्टैक दिखाता है ।

32       % Push 32 (ASCII for space)
O        % Push 0
i        % Input array
         % STACK: 32, 0, [2,3,6,8,2]
t        % Duplicate
         % STACK: 32, 0, [2,3,6,8,2], [2,3,6,8,2]
tn:      % Push [1 2 ... n] where n is length of input array
         % STACK: 32, 0, [2,3,6,8,2], [2,3,6,8,2], [1,2,3,4,5]
o        % Modulo 2
         % STACK: 32, 0, [2,3,6,8,2], [2,3,6,8,2], [1,0,1,0,1]
Eq       % Multiply by 2, subtract 1
         % STACK: 32, 0, [2,3,6,8,2], [2,3,6,8,2], [1,-1,1,-1,1]
*        % Multiply elementwise
         % STACK: 32, 0, [2,3,6,8,2], [2,-3,6,-8,2]
Ys       % Cumulative sum
         % STACK: 32, 0, [2,3,6,8,2], [2,-1,5,-3,1]
         % The top-most array is the positions where the entries of the second-top
         % array will be written. But postions cannot be less than 1; if that's
         % the case we need to correct so that the minimum is 1. If this happens,
         % it means that the frog has gone further left than where he started
t        % Duplicate
1hX<     % Append 1 and compute minimum. So if the original minimum is less than 1
         % this gives that minimum, and if it is more than 1 it gives 1
         % STACK: 32, 0, [2,3,6,8,2], [2,-1,5,-3,1], -3
-        % Subtract
         % STACK: 32, 0, [2,3,6,8,2], [5 2 8 0 2]
Q        % Add 1
         % STACK: 32, 0, [2,3,6,8,2], [6 3 9 1 3]
(        % Assign values (top array) to specified positions (second-top) into array
         % which contains a single 0 (third-top). Newer values overwrite earlier
         % values at the same position
         % STACK: 32, [8 0 2 0 0 2 0 0 6]
V        % Convert to string. This produces spaces between the numbers
         % STACK: 32, '8 0 2 0 0 2 0 0 6'
h        % Concatenate with initial 32 (space). This converts to char
         % STACK: ' 8 0 2 0 0 2 0 0 6'
         % Thanks to this initial space, all zeros that need to be replaced by '_'
         % are preceded by spaces. (In this example that initial space would not
         % be needed, but in other cases it will.) Other zeros, which are part of
         % a number like '10', must not be replaced
' 0'     % Push this string: source for string replacement
         % STACK: ' 8 0 2 0 0 2 0 0 6', ' 0 '
95       % Push 95 (ASCII for '_'): target for string replacement
         % STACK: ' 8 0 2 0 0 2 0 0 6', ' 0 ', 95
Zt       % String replacement
         % STACK: ' 8_2__2__6'
Xz       % Remove spaces. Implicit display
         % STACK: '8_2__2__6'

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

मुझे लगता है कि आप '0'इसके स्थान पर दो बाइट्स बचा सकते हैं ' 0 ', क्योंकि Xzरिक्त स्थान को हटा देता है

— बी मेहता

1

@ B.Mehta धन्यवाद। मैं शुरू में ऐसा ही किया, लेकिन दुर्भाग्य से यह क्योंकि तब काम नहीं करता, '0'में '10'भी बदल दिया जाता है। इसलिए मैं एक प्रारंभिक 32भी जोड़ता हूं

— लुइस मेंडो

आह, मेरी गलती

— बी मेहता

@ B.Mehta नहीं, यह मेरे स्पष्टीकरण से बिल्कुल स्पष्ट नहीं था। मैं बाद में स्पष्ट करूंगा कि

— लुइस मेंडो

1

विवरण में मॉड 2 सरणी उलटा है। और भी, ' 0'बस के रूप में अच्छी तरह से काम नहीं करेगा ?

— एमिगा

4

PHP, 100 101 99 104 बाइट्स

for($p=-1;$d=$argv[++$k];+$i<$p?:$i=$p,$x>$p?:$x=$p)$r[$p+=$k&1?$d:-$d]=$d;for(;$i<=$x;)echo$r[$i++]?:_;

कमांड लाइन तर्कों से इनपुट लेता है; साथ चलाना -nr।

टूट - फूट

for($p=-1;          // init position
    $d=$argv[++$k]; // loop $d through command line arguments
    +$i<$p?:$i=$p,          // 3. $i=minimum index
    $x>$p?:$x=$p            // 4. $x=maximum index
)
    $r[
        $p+=$k&1?$d:-$d     // 1. jump: up for odd indexes, down else
    ]=$d;                   // 2. set result at that position to $d
for(;$i<=$x;)           // loop $i to $x inclusive
    echo$r[$i++]?:_;        // print result at that index, underscore if empty

— टाइटस
स्रोत

यह कैसे उदाहरण इनपुट को संभालता है 2,3,6,8,2, जहां 8लिली पैड के "शुरुआत" को "पीछे" कूदता है?

— AdmBorkBork

@AdmBorkBork PHP नकारात्मक सरणी अनुक्रमित का समर्थन करता है।

— टाइटस

आह, यह नहीं पता था। धन्यवाद!

— AdmBorkBork

4

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

संपादित करें: क्योंकि ओपी ने स्पष्ट किया कि केवल सीमा उपलब्ध मेमोरी होनी चाहिए, यह हार्डकोडेड अधिकतम सीमा पर निर्भर होने के बजाय आवश्यक स्थान को आवंटित करने के लिए अद्यतन किया गया था।

f=(a,x='',p=M=0)=>a.map(n=>x[(p-=(i=-i)*n)<m?m=p:p>M?M=p:p]=n,i=m=1)&&x?x.join``:f(a,Array(M-m).fill`_`,-m)

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

यह फ़ंक्शन दो पासों में काम करता है:

पहले पास के दौरान:
- 'मेंढक पॉइंटर' pको इनिशियलाइज़ किया गया है 0।
- xचर रिक्त स्ट्रिंग पर सेट किया गया है, इतना है कि यह संशोधित करने के लिए सभी प्रयास बस अनदेखी कर रहे हैं।
- हम गणना करते हैं mऔर Mजो क्रमशः न्यूनतम और अधिकतम मूल्यों तक पहुंचते हैं p।
- इस पास के अंत में: हम एक पुनरावर्ती कॉल करते हैं f()।
दूसरे पास के दौरान:
- pके लिए आरंभिक है -m।
- xवर्णों M-mसे भरे आकार की एक सरणी पर सेट है _।
- हम सही स्थिति में संख्याएँ सम्मिलित करते हैं x।
- इस पास के अंत में: हम एक सम्मिलित संस्करण लौटाते हैं x, जो अंतिम परिणाम है।

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

कोड स्निपेट दिखाएं

f=(a,x='',p=M=0)=>a.map(n=>x[(p-=(i=-i)*n)<m?m=p:p>M?M=p:p]=n,i=m=1)&&x?x.join``:f(a,Array(M-m).fill`_`,-m)

console.log(f([5]));                  // ____5
console.log(f([4,3,2,1]));            // 3124
console.log(f([5,3,2,1]));            // _3125
console.log(f([2,3,6,8,2]));          // 8_2__2__6
console.log(f([10,3,12,4,1,12,16]));  // ___12__3__10____41__1216
console.log(f([100,4,7,2,2]));        // _..._4___1002_2

स्निपेट का विस्तार करें

— Arnauld
स्रोत

यह उन मामलों के लिए विफल होता है जहां मेंढक सूचकांक -998 से नीचे या 1002 से ऊपर कूदता है। उदाहरण: [1100]स्थिति के 1002बजाय स्थिति में मुद्रित संख्या में परिणाम 1100।

— अंडरस्कोर

1

@nderscore यह 8 बाइट्स की कीमत पर तय किया गया है।

— अरनुलद

बहुत बढ़िया! अच्छा तरीका भी :)

— अंडरस्कोर

4

आर , 100 97 96 बाइट्स

function(x){p=cumsum(x*c(1,-1))[seq(x^0)]
p=p+max(1-p,0)
v=rep('_',max(p));v[p]=x
cat(v,sep='')}

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

पंक्ति 1 उन सभी पदों को खोजती है जहां कूदना है। सबसे पहले, सभी जंप को x1 या in1 से गुणा किया जाता है और फिर संचयी योग का उपयोग करके अंतिम स्थिति में बदल दिया जाता है। c(-1,1)यदि आवश्यक हो तो वेक्टर को पुनर्नवीनीकरण किया जाता है, हालांकि, जब xलंबाई 1 की होती है, xतो इसके बजाय पुनर्नवीनीकरण किया जाता है। इसलिए केवल seq(x^0)(समतुल्य seq_along(x)) रकम मानी जाती है। (एक चेतावनी तब उत्पन्न होती है जब लंबाई x2 से अधिक नहीं होती है लेकिन यह परिणाम को प्रभावित नहीं करती है)

पंक्ति 2 कूदने की स्थिति को बढ़ाती है ताकि सभी कम से कम 1 हो।

लाइनें 3 और 4 आउटपुट बनाते हैं और इसे प्रिंट करते हैं।

Giuseppe से from1 बाइट

— रॉबर्ट हैकेन
स्रोत

साथ साफ सुथरी चाल seq(x^0)!

— Giuseppe

-p+11-pएक बाइट कम के लिए हो सकता है ।

— Giuseppe

@Giuseppe आह, निश्चित रूप से, धन्यवाद!

— रॉबर्ट हैकेन

3

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

f=x=>x.map((y,i)=>o[j=(j-=i%2?y:-y)<0?o.unshift(...Array(-j))&0:j]=y,o=[],j=-1)&&[...o].map(y=>y||'_').join``

<!-- snippet demo: -->
<input list=l oninput=console.log(f(this.value.split(/,/)))>
<datalist id=l><option value=5><option value="4,3,2,1"><option value="5,3,2,1"><option value="2,3,6,8,2"><option value="10,3,12,4,1,12,16"><option value="100,4,7,2,2"></datalist>

स्निपेट का विस्तार करें

टिप्पणी की:

f=x=>x.map((y,i)=>o[j=(j-=i%2?y:-y)<0?o.unshift(...Array(-j))&0:j]=y,o=[],j=-1)&&[...o].map(y=>y||'_').join``
                /* initialize output array [] and index j at -1: */  o=[],j=-1
     x.map((y,i)=> /* iterate over all items in input x (y=item, i=index) */  )
                      (j-=i%2?y:-y) /* update j +/-y based on if index i is odd */
                                   <0? /* if resulting j index is less than zero */
                                      o.unshift(...Array(-j)) /* prepend -j extra slots to the output array */
                                                             &0 /* and give result 0 */
                                                               :j /* else give result j */
                    j= /* assign result to j */
                  o[ /* assign y to output array at index j */   ]=y
   /* short-circuit && then spread output array to fill any missing entries */ &&[...o]
                                                      /* fill falsey slots with '_' */ .map(y=>y||'_')
                                                                         /* join with empty spaces */ .join``

— nderscore
स्रोत

3

पर्ल 6 , 68 67 बाइट्स

{(my @a)[[[\+] |(1,-1)xx*Z*$_].&{$_ X-min 1,|$_}]=$_;[~] @a X//"_"}

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

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

पहले यह संचयी कूद स्थान निर्धारित करता है:

[[\+] |(1,-1)xx*Z*$_]
                  $_  # Input array.          e.g.  2, 3, 6, 8, 2
      |(1,-1)xx*      # Infinite sequence:          1,-1, 1,-1, 1...
                Z*    # Zip-multiplied.       e.g.  2,-3, 6,-8, 2
 [\+]                 # Cumulative addition.  e.g.  2,-1, 5,-3,-1

फिर यह उन्हें सभी नंबरों से न्यूनतम संख्या (लेकिन अधिकतम 1) घटाकर 0-आधारित सरणी सूचकांकों में बदल देता है:

.&{$_ X-min 1,|$_}    #                       e.g.  5, 2, 8, 0, 2

फिर यह उन सूचकांकों को सौंपे गए इनपुट नंबरों के साथ एक सरणी बनाता है:

(my @a)[   ]=$_;      #                       e.g.  8, Nil, 2, Nil, Nil, 2 Nil, Nil, 6

अंत में यह अपरिवर्तित तत्वों के स्थान पर अंडरस्कोर के साथ एक स्ट्रिंग को एरेनेट करता है:

[~] @a X//"_"         #                       e.g.  8_2__2__6

— SMLS
स्रोत

3

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

-2 (और आगे -2 की अनुमति देते हुए) FrownyFrog को धन्यवाद (उपसर्ग अनुप्रयोग की कार्यक्षमता [पोस्ट-चैलेंज] त्वरित उपयोग करें Ƥ)

ṚƤḅ-µCṀ»0+µṬ€×"³Ṛo/o”_;⁷

इसे ऑनलाइन आज़माएं! पूर्ण प्रोग्राम, एक ही कार्यक्षमता का उपयोग कर एक परीक्षण सूट के लिए, यहां क्लिक करें ।

कैसे?

ṚƤḅ-µCṀ»0+µṬ€×"³Ṛo/o”_;⁷ - Main link: list a       e.g. [ 5, 3, 2, 1]
 Ƥ                       - prefix application of:
Ṛ                        -  reverse                e.g. [[5],[3,5],[2,3,5],[1,2,3,5]]
   -                     - literal minus one
  ḅ                      - from base (vectorises)  e.g. [ 5, 2, 4, 3]=
    µ                    - start a new monadic chain - call that list c
                         - [code to shift so minimum is 1 or current minimum]
     C                   - complement (vectorises) e.g. [-4,-1,-3,-2]
      Ṁ                  - maximum                 e.g.     -1
       »0                - maximum of that & zero  e.g.      0
         +               - add to c (vectorises)   e.g. [ 5, 2, 4, 3]
          µ              - start a new monadic chain - call that list d
           Ṭ€            - untruth €ach            e.g. [[0,0,0,0,1],[0,1],[0,0,0,1],[0,0,1]]
               ³         - the program input (a)
             ×"          - zip with multiplication e.g. [[0,0,0,0,5],[0,3],[0,0,0,2],[0,0,1]]
                Ṛ        - reverse                      [[0,0,1],[0,0,0,2],[0,3],[0,0,0,0,5]]
                 o/      - reduce with or          e.g. [0,3,1,2,5]
                    ”_   - '_'
                   o     - or (replace 0 with '_') e.g. ['_',3,1,2,5]
                      ;⁷ - concatenate a newline   e.g. ['_',3,1,2,5, '\n']
                         - implicit print

टिप्पणियाँ:

एक नईलाइन का अंतिम निष्कर्ष, ;⁷ऐसे मामलों के लिए है जब _आउटपुट में कोई प्रकट नहीं होता है, जिस स्थिति में निहित प्रिंट [3, 1, 2, 4]उदाहरण की तरह कुछ के बजाय सूची का प्रतिनिधित्व प्रदर्शित करेगा, जैसे _3125। कोई अनुगामी न्यूलाइन के लिए एक चरित्र सूचियों की सूची को जोड़ने के ;⁷साथ बदल सकता है ;““, [[''],['']](किसी करीबी की ”आवश्यकता नहीं है क्योंकि यह एक कार्यक्रम का अंतिम चरित्र है)।

असत्य फ़ंक्शन, Ṭ, एक 1इनपुट के साथ एक सूची देता है यह इनपुट में है, एक प्राकृतिक संख्या के लिए, n जो n-1 है 0 s है जिसके बाद 1इनपुट संख्याओं को गुणा द्वारा बाईं ओर से उनकी सही दूरी पर रखने की अनुमति मिलती है । उलट, Ṛ, के लिए आवश्यक है बाद में मेंढक-यात्राओं के बजाय ऊपर लिख पहले लोगों को जब साथ में कमी या, o/, किया जाता है।

— जोनाथन एलन
स्रोत

1,-ṁ×µ+\→ UƤ_@/€?

— फ्रॉन्फ्रॉग में

Ƥइस बिंदु पर एक फीचर नहीं लिखा गया था, लेकिन हां यह काम करेगा। बेहतर है UƤḅ€-(चूंकि आधार -1 से रूपांतरण, इसके बाद ...,1,-1,1,-1,1,-1,1और फिर गुणा करने जैसा है )।

— जोनाथन एलन

... या यहां तक कि वेक्टराइज़ के UƤḅ-बाद से ḅ:) (मैं भी सादे रिवर्स के साथ चला गया Ṛ, क्योंकि हमें ऊपर की जटिलता की आवश्यकता नहीं है, U)

— जोनाथन एलन

1

एपीएल (डायलॉग यूनिकोड) , 45 30 बाइट्स ^{एसबीसीएस}

{∊⍕¨⍵@i⍴∘'_'⌈/1+i←(⊢-1⌊⌊/)-\⍵}

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

-\⍵बारी -- बारी से तर्क को स्कैन करें और+

(⊢ - 1 ⌊ ⌊/)उस से ( ⊢) घटाएँ 1 या न्यूनतम (⌊/ ), जो भी छोटा हो ( ⌊)

i← को आवंटित i

⌈/ 1+ वेतन वृद्धि और अधिकतम ले

⍴∘'_' कई अंडरस्कोर का उत्पादन करें

⍵@i तर्क से संख्या डालें (⍵ ) से पदों पर रखेंi

∊⍕¨ प्रत्येक प्रारूप और समतल

— NGN
स्रोत

0

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

->a{i=1;j=c=0;a.map{|x|[c-=x*i=-i,x]}.to_h.sort.map{|x,y|[?_*[x+~j,0*j=x].max,y]}*''}

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

प्रत्येक छलांग के बाद पदों को रिकॉर्ड करता है, डुप्लिकेट को हटाने के लिए परिणामी सरणी को हैश में कनवर्ट करता है (प्रत्येक डुप्लिकेट स्थिति में अंतिम मान को संरक्षित करता है), और फिर अंडरस्कोर की आवश्यक राशि के साथ मूल्यों को चमकता है।

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

0

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

J=input()
i=sum(J)
l=['_']*2*i
v=i,
d=1
for j in J:i+=d*j;d=-d;l[i]=`j`;v+=i,
print''.join(l[min(v):max(v)+1])

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

— TFeld
स्रोत

लिली पैड कूद

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

MATL , 35 34 बाइट्स

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

PHP, 100 101 99 104 बाइट्स

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

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

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

आर , 100 97 96 बाइट्स

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

टिप्पणी की:

पर्ल 6 , 68 67 बाइट्स

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

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

कैसे?

एपीएल (डायलॉग यूनिकोड) , 45 30 बाइट्स एसबीसीएस

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

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

एपीएल (डायलॉग यूनिकोड) , 45 30 बाइट्स ^{एसबीसीएस}