खरगोश की तरह छोड़ो!

41

किसी भी उचित प्रारूप में गैर-नकारात्मक पूर्णांकों की सूची को देखते हुए, उस पर पुनरावृति, आपके द्वारा कहे गए पूर्णांक के रूप में कई तत्वों को छोड़ देना।

यहाँ एक उदाहरण दिया गया है:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | []
 ^ First element, always include it
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0]
    ^ Skip 0 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1]
          ^ Skip 1 element
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2]
                   ^ Skip 2 elements
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2] | [0, 1, 2, 3]
Skip 3 elements; you're done

एक और काम किया उदाहरण है, सभी समान-डेल्टास नहीं:

[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | []
 ^ First element, always include it
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4]
                ^ Skip 4 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3]
                            ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3]
                                        ^ Skip 3 elements
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] | [4, 3, 3, 4]
Skip 4 elements; you're done

एक सीमा से बाहर का उदाहरण:

[0, 2, 0, 2, 4, 1, 2] | []
^ First element, always include it
[0, 2, 0, 2, 4, 1, 2] | [0]
    ^ Skip 0 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2]
             ^ Skip 2 elements
[0, 2, 0, 2, 4, 1, 2] | [0, 2, 4]
Skip 4 elements; you're done (out of bounds)

नियम

  • आप इन लोगों के बीच किसी भी उबाऊ धोखा का उपयोग नहीं कर सकते हैं , वे चुनौती को उबाऊ और निर्बाध बनाते हैं।
  • आपको केवल अंतिम परिणाम लौटाना / प्रिंट करना चाहिए। STDERR आउटपुट को अनदेखा किया जाता है।
  • आपको किसी भी आधार में अंकों की एक स्ट्रिंग के रूप में इनपुट नहीं मिल सकता है (उदाहरण के लिए "0102513162")।
  • आपको इनपुट के लिए बाएं से दाएं क्रम का उपयोग करना चाहिए।
  • काम के उदाहरणों में, यदि आप सीमा से बाहर जाते हैं, तो निष्पादन समाप्त हो जाता है जैसे कि अन्यथा।
  • आपको 00 तत्वों को छोड़ देने के लिए उपयोग करना चाहिए ।
  • []इनपुट के रूप में खाली सूची ( ) को देखते हुए , आपको वापस लौटना चाहिए []।

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

[]                                                     => []
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]                     => [0, 1, 3, 7]
[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]                   => [5, 2, 1, 0]
[0, 1, 0, 2, 5, 1, 3, 1, 6, 2]                         => [0, 1, 2, 3]
[4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2] => [4, 3, 3, 4]
[0, 2, 0, 2, 4, 1, 2]                                  => [0, 2, 4]

यह कोड-गोल्फ है , इसलिए सबसे कम उत्तर जीतता है!

code-golf  array-manipulation 
— आउटगोल्फर को एरिक करें
स्रोत
1
क्या मेरे एरे में ट्रेलिंग जीरो होना ठीक है? मुझे बचा लेगा ~ 18 बाइट्स
— रोमन ग्रैफ
@EriktheOutgolfer क्या हम एक स्ट्रिंग सरणी का उत्पादन कर सकते हैं और खाली तारों को पीछे छोड़ सकते हैं?
— TheLethalCoder
1
@ TheLethalCoder क्षमा करें, मैं नहीं कहूंगा कि यह उचित नहीं है ... क्या आप केवल ट्रेलिंग ""एस नहीं निकाल सकते हैं ?
— निकोल आउटफोलर जूल
2
@ RomanGräf क्षमा करें, लेकिन नहीं, यह बहुत अस्पष्ट होगा क्योंकि ऐसे मामले हैं जो आपको 0आउटपुट में अनुगामी होना चाहिए ।
— निकोल आउटफोलर जूल

जवाबों:

14

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

f=lambda x:x and x[:1]+f(x[x[0]+1:])

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

— छड़ी
स्रोत
मैं उम्मीद कर रहा था कि आउटगोल्फ हो सकता है, लेकिन यह बुरी तरह से नहीं :)
— श्री एक्सकोडर
क्या आप इसके x[0]बजाय नहीं कर सकते x[:1]?
— आउटगोल्फ जूल
@EriktheOutgolfer हाँ, लेकिन इसे एक सूची बनाने की आवश्यकता है, इसलिए यह होगा[x[0]]
— Rod
@ रोड आप किसी भी बाइट को किसी भी तरह से नहीं बचा रहे हैं x[:1]...f=lambda x:x and[x[0]]+f(x[x[0]+1:])
— आउटगॉल्फ जूल
13

पायथन 2 , 49 44 * 41 बाइट्स

पार किया 44 अभी भी नियमित है 44 :(

* -3 ASCII- केवल के लिए धन्यवाद ।

l=input()
while l:print l[0];l=l[l[0]+1:]

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

परिणामों को एक नई रेखा से अलग करता है, जैसा कि ओपी ने चैट में अनुमति दी है। मुझे नहीं लगता कि यह गैर-पुनरावर्ती पूर्ण कार्यक्रम के रूप में किसी भी छोटे हो सकता है ।

यह कैसे काम करता है?

  • l=input() - मानक इनपुट से सूची पढ़ता है।

  • while l: - इस तथ्य का दुरुपयोग करता है कि खाली सूची पायथन में झूठी हैं, सूची खाली होने तक लूप करती है।

  • print l[0]; - सूची के पहले तत्व को प्रिंट करता है।

  • l=l[l[0]+1:]- "एक खरगोश की तरह स्किप करता है" - l[0]+1सूची से पहला भाग लेता है ।

एक उदाहरण लेते हैं

[5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]इनपुट के रूप में सूची को देखते हुए , कोड निम्नलिखित कार्य करता है (ऊपर स्पष्टीकरण के अनुसार) - सरणी के पहले आइटम को प्रिंट करता है:, 5पहले 6 को ट्रिम करें [2, 1, 2, 1, 0, 0]:। हम फिर 2पहले 3 को प्रिंट और ट्रिम करते हैं [1,0,0]:। इसी तरह, हम उत्पादन करते हैं 1, पहले 2 फसल लेते हैं, और हम प्राप्त करते हैं [0]। बेशक, 0मुद्रित किया जाता है और कार्यक्रम समाप्त हो जाता है।

— मिस्टर एक्सकोडर
स्रोत
— केवल
9

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

a=>a.map((n,i)=>a.splice(i+1,n))&&a


let f = 
a=>a.map((n,i)=>a.splice(i+1,n))&&a

console.log(f([]))                                                     // => []
console.log(f([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))                     // => [0, 1, 3, 7]
console.log(f([5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0]))                   // => [5, 2, 1, 0]
console.log(f([0, 1, 0, 2, 5, 1, 3, 1, 6, 2]))                         // => [0, 1, 2, 3]
console.log(f([4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2])) // => [4, 3, 3, 4]
console.log(f([0, 2, 0, 2, 4, 1, 2]))                                  // => [0, 2, 4]
स्निपेट का विस्तार करें

पुराना घोल 39 बाइट्स

a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

-3 बाइट्स @ThePirateBay को धन्यवाद

— जोहान कार्लसन
स्रोत
39 बाइट्सa=>a.map(n=>i--||r.push(i=n),r=i=[])&&r
8

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

SequenceCases[#,{x_,y___}/;Tr[1^{y}]<=x:>x]&

विकल्प:

SequenceCases[#,{x_,y___}/;x>=Length@!y:>x]&
SequenceCases[#,l:{x_,___}/;x>Tr[1^l]-2:>x]&
— मार्टिन एंडर
स्रोत
7

सी #, 68 बाइट्स

a=>{for(int i=0;i<a.Count;i+=a[i]+1)System.Console.Write(a[i]+" ");}

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

पूर्ण / प्रारूपित संस्करण:

namespace System
{
    class P
    {
        static void Main()
        {
            Action<Collections.Generic.List<int>> f = a =>
            {
                for (int i = 0; i < a.Count; i += a[i] + 1)
                    System.Console.Write(a[i] + " ");
            };

            f(new Collections.Generic.List<int>() { });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 5, 1, 2, 3, 4, 5, 2, 1, 2, 1, 0, 0 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 1, 0, 2, 5, 1, 3, 1, 6, 2 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 4, 5, 1, 3, 8, 3, 0, 1, 1, 3, 1, 2, 7, 4, 0, 0, 1, 2 });Console.WriteLine();
            f(new Collections.Generic.List<int>() { 0, 2, 0, 2, 4, 1, 2 });Console.WriteLine();

            Console.ReadLine();
        }
    }
}

सूची वापस करना 107 बाइट्स पर लंबा है।

a=>{var l=new System.Collections.Generic.List<int>();for(int i=0;i<a.Count;i+=a[i]+1)l.Add(a[i]);return l;}
— TheLethalCoder
स्रोत
2
किसी ने इसे नीचा क्यों दिखाया है?
— लीथलॉकर
अपने स्कोर को गोल करने और एक सही 5k बनाने के लिए?
— थॉमस अय्यूब
@ThomasAyoub हम केवल यह मान सकते हैं कि यह OCD के साथ कोई था हाँ।
— TheLethalCoder
6

भूसी , 8 6 बाइट्स

←TU¡Γ↓

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

-2 बाइट्स (और एक पूरी तरह से नया समाधान विचार) लियो को धन्यवाद!

व्याख्या

मैं सूची पैटर्न मैच फ़ंक्शन का उपयोग कर रहा हूं Γ। यह fसिर xऔर पूंछ के साथ एक फ़ंक्शन और एक सूची लेता है xs, और पर लागू होता fहै xऔर xs। यदि सूची खाली है, तो Γअपने प्रकार के अनुरूप एक डिफ़ॉल्ट मान लौटाता है, इस स्थिति में एक खाली सूची। हम होने के fलिए ↓, जो xतत्वों से गिरता है xs। यह फ़ंक्शन तब पुनरावृत्त होता है और परिणामी तत्वों को एक सूची में एकत्र किया जाता है।

←TU¡Γ↓  Implicit input, e.g. [0,2,0,2,4,1,2]
    Γ↓  Pattern match using drop
   ¡    iterated infinitely: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[],[],[],...
  U     Cut at first repeated value: [[0,2,0,2,4,1,2],[2,0,2,4,1,2],[4,1,2],[]]
 T      Transpose: [[0,2,4],[2,0,1],[0,2,2],[2,4],[4,1],[1,2],[2]]
←       First element: [0,2,4]
— Zgarb
स्रोत
आप ø का डिफ़ॉल्ट मान छोड़ सकते हैं, और सब कुछ अभी भी जादुई रूप से काम करेगा :)
— सिंह
या, इससे भी कम बाइट्स के लिए, tio.run/##yygtzv7//1HbhJDQQwvPTX7UNvn////RBjpGOiBsomOoYxQLAAAA
— Leo
@ लिओ ओह, यह चतुर है!
— ज़र्गब जूल
आपने सीडब्ल्यू क्यों किया?
— आउटगॉल्फ जूल
@ ErikTheOutgolfer यह एक गलती थी (मैं अपने फोन पर हूँ और स्पष्ट रूप से दुर्घटना से कुछ धक्का दिया)। मैं इसे पूर्ववत करने की कोशिश कर रहा हूँ ...
— ज़र्ब जूल
5

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

VQ aY.(Q0VeY .x.(Q0 ;Y

एक बेकार बाइट को हटा दिया

— डेव
स्रोत
मैं वहाँ 23 बाइट्स देखता हूँ।
— निकोलग्राफ जूल
टाइपो :) क्षमा करें ...
— डेव
3
मुझे यकीन नहीं है कि आपके पास डाउन वोट क्यों है। इस बात की संभावना है कि जब आपने अपने उत्तर को ठीक करने का संपादन किया, तो यह "स्वचालित डाउन वोट" हो गया। इस स्वचालित डाउनवोट के कारण भ्रामक और भयानक हैं, लेकिन ऐसा होता है यदि सिस्टम आपके उत्तर को "निम्न गुणवत्ता" मानता है, जो कि इस आंकड़े पर आधारित है। यह भी संभव है कि किसी को आपका जवाब पसंद नहीं आया, लेकिन मुझे इस समय कुछ भी गलत नहीं दिख रहा है इसलिए मुझे यकीन नहीं है कि ऐसा क्यों होगा।
— गेहूं जादूगर
मुझे खुशी है कि आप पायथ का उपयोग कर रहे हैं!
— इसहाक
3

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

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

.+
$*
((1)*¶)(?<-2>1*¶)*
$1
%M`.
0$

इनपुट और आउटपुट एक ट्राइलिंग लाइनफीड के साथ लाइनफीड-अलग होते हैं।

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

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

ब्रेन-फ्लैक , 64 बाइट्स

([]){{}(({})<>)<>{({}[()]<{}>)}{}([])}{}<>([]){{}({}<>)<>([])}<>

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

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack
— रिले
स्रोत
7
बकवास! मैंने एक समाधान लिखा, और फिर इसे पोस्ट करने के लिए नीचे स्क्रॉल किया, लेकिन यह पता चला कि हमने सटीक एक ही समाधान बाइट-फॉर-बाइट लिखा था ! यहाँ तक कि मामूली विवरण भी ({}[()]<{}>)बनाम ({}<{}>[()])ही थे! क्या संयोग है!
— DJMcMayhem
@DJMcMayhem ने सभी प्रसिद्धि XD
— क्रिस्टोफर
मैंने बाइट समान समाधान के लिए एक बाइट भी किया, लेकिन मैंने इसे 4 बाइट्स के साथ नीचे कर दिया । बस कुछ देरी से प्रतियोगिता :)
— गेहूं जादूगर
2

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

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={}
— user202729
स्रोत
मैं इस साफ-सुथरे कोड को आगे बढ़ाने का विरोध नहीं कर सकता था; मेरा जवाब नीचे है।
— श्री। छिपकली
2

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

n=>{var t="";for(int i=0;i<n.Length;i+=n[i]+1)t+=n[i]+" ";return t;}

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

पूर्णांक के एक सरणी के रूप में इनपुट लेता है, एक स्ट्रिंग देता है जिसमें गैर-स्किप किए गए मान होते हैं।

— jkelm
स्रोत
इसे करने का अच्छा तरीका और मुद्रण के रूप में एक ही गिनती में आता है।
— TheLethalCoder
मुझे सरल समाधान पसंद हैं। फिर भी
— लिटक्
इसे छोटा कर देता है क्योंकि आप ज्यादातर समय रिटर्न दे सकते हैं। हालांकि यह using System.Linq;एक सामान्य लूप के साथ अंतर्निहित वापसी के बीच टॉस है ।
— द लीथेलकोडर
2

आर, 58 बाइट्स

f=function(x,p=1){cat(z<-x[p]);if(p+z<sum(x|1))f(x,p+z+1)}

पुनरावर्ती कार्य। एक सदिश xको तर्क के रूप में लेता है और एक सूचक को सूचित करता है p। यह इसी प्रविष्टि को प्रिंट xकरता है, जाँच करता है कि p+x[p]क्या सीमा से बाहर जाएगा, और यदि नहीं, तो नए पॉइंटर के लिए फ़ंक्शन को कॉल करता है।

f=function(x,p=1,s=x[1])`if`((z<-x[p]+p+1)>sum(x|1),s,f(x,z,c(s,x[z])))

यह एक तुलनीय समाधान है जो अंकों को प्रिंट करने के बजाय एक उचित वेक्टर देता है।

— JAD
स्रोत
के इनपुट के बारे में क्या numeric(0)? उर्फ खाली सरणी।
— Giuseppe
@Giuseppe जब मैं अपने पीसी के पीछे हूँ, तो मैं इसे देख लूँगा
— JAD
— Giuseppe
2

जावा (ओपनजेडके 8) , 53 बाइट्स

@ PunPun1000 और @TheLethalCoder को धन्यवाद

a->{for(int n=0;;n+=1+a[n])System.out.println(a[n]);}

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

— रोमन ग्रैफ़
स्रोत
क्या मेरे C # उत्तर की तरह, परिणाम प्रिंट करना, आपको कुछ भी बचाएगा?
— TheLethalCoder
@TheLethalCoder बीमार कोशिश
— रोमन ग्रैफ
क्या आप nलूप में जाकर बाइट बचा सकते हैं ?
— TheLethalCoder
इसके अलावा इस समय काम नहीं कर रहा है।
— द लीथेलकोडर
आप एक परन को याद कर रहे हैं (a[n+=1+a[n]]। फ़ंक्शन सही मान आउटपुट करने के बाद भी एक त्रुटि फेंकता है, मुझे इस बात की सहमति नहीं है कि यह अनुमति दी गई है या नहीं (प्रश्न मानक त्रुटि के लिए कुछ भी कहता है उपेक्षा)। यदि वह इरादा था, तो आप n<a.lengthलूप के लिए निकाल सकते हैं । अंत में TIO कोड उस तरह से नहीं चलता है, जैसा कि परन के साथ भी है। समारोह एक होना चाहिए Consumer<int[]>और उपयोगfunc.accept(test)
— PunPun1000
2

ऐलिस , 15 बाइट्स

/$.. \h&
\I@nO/

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

इनपुट और आउटपुट एक अलग-थलग-अलग-अलग सूचियों की दशमलव पूर्णांक।

व्याख्या

/   Switch to Ordinal mode.
I   Read a line.
.   Duplicate it.
n   Logical NOT (gives truthy if we're at EOF).
/   Switch to Cardinal.
    The IP wraps around to the left.
\   Switch to Ordinal.
$@  Terminate the program if we're at EOF.
.   Duplicate the input line again.
O   Print it.
\   Switch to Cardinal.
h   Increment the value.
&   Store the result in the iterator queue.
    The program wraps around to the beginning.

इटैलर कतार में पूर्णांक n को संचय करने से अगला कमांड n बार निष्पादित होता है। दर्पण जैसे /कमांड नहीं हैं, इसलिए अगला कमांड होगा I। इसलिए अगर हम सिर्फ वैल्यू x पढ़ते हैं और प्रिंट करते हैं , तो हम अगले पुनरावृत्ति पर x + 1 मान पढ़ेंगे , जिनमें से अंतिम स्टैक के ऊपर समाप्त होगा। यह आवश्यक संख्या सूची तत्वों को छोड़ देता है।

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

गणितज्ञ , 37 (30)

आगे उपयोगकर्ता 202029 के ठीक विधि के गोल्फिंग।

±{a_,x___}={a}~Join~±{x}~Drop~a
±_={}

नियम स्पष्ट रूप से आउटपुट स्वरूप को स्पष्ट नहीं करते हैं, इसलिए हो सकता है:

±{a_,x___}=a.±{x}~Drop~a
±_={}

दूसरे फ़ंक्शन के लिए आउटपुट ऐसा दिखता है: 0.2.4.{}- विशेष रूप {}से अभी भी एक खाली सेट के लिए वापस आ गया है, अंतिम नियम के अनुसार।

— Mr.Wizard
स्रोत
1
±Drop[{x},a]हो सकता है ±{x}~Drop~aक्योंकि ±की तुलना में कम पूर्वता है Infix।
— जुंगहवान मिन
@JungHwanMin मुझे याद आया कि; धन्यवाद!
— श्री। छिपकली
2

ब्रेन-फ्लैक , 64 60 बाइट्स

4 बाइट्स 0 से एक विचार के आधार पर बचाते हैं '

([]){{}(({})<>())<>{({}[()]<{}>)}{}([])}{}<>{({}[()]<>)<>}<>

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

एनोटेट

([]){{}            #{Until the stack is empty}
  (({})<>())<>     #{Put n+1 to the offstack}
  {({}[()]<{}>)}{} #{Remove n items from the top}
([])}{}            #{End until}
<>                 #{Swap stacks}
{({}[()]<>)<>}<>   #{Move everything back onto the left stack decrementing by 1}
— गेहूं का जादूगर
स्रोत
1

रूबी, ३६ ३३ ३१

f=->l{a,*l=l;a&&f[l.drop(p a)]}

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

— क्रिस्टियन लुपस्कू
स्रोत
आपको f=हेडर तत्व के रूप में घटाना संभव है ।
— कैनशोडज़
@ सेथ्रिन भले ही मुझे इसे पुनरावर्ती कहने की आवश्यकता हो?
— क्रिस्टियन लुपस्कू
हम्म, अच्छा सवाल है। मुझे नहीं लगता। मुझे आपके समाधान के बारे में बहुत पसंद है, वैसे।
— कैनशोडेज़
1

पायथन 2.4, 85 बाइट्स

इसके साथ अजगर में जीतने का कोई मौका नहीं है, लेकिन मुझे ओनेलियर्स से प्यार है और यह दूसरों के लिए दिलचस्प हो सकता है।
पता चला, समझ के अंदर निर्माण सूची का उपयोग करने के लिए एक फैंसी जादू की चाल है, लेकिन यह केवल 2.4 में काम करता है और कुछ संपादन के साथ <= 2.3 में
locals()['_[1]']है। पायथन _[1]सूची के लिए गुप्त नाम बनाता है , जबकि इसे बनाया जाता है और इसे इसमें संग्रहीत किया जाता है locals। इसके अलावा नाम _[2], _[3]... का उपयोग नेस्टेड सूचियों के लिए किया जाता है।

lambda n:[j for i,j in enumerate(n)if i==len(locals()['_[1]'])+sum(locals()['_[1]'])]

तो यह पहले से ही जोड़े गए तत्वों की संख्या और उनकी राशि को गिनता है। परिणाम अगले वांछित तत्व का सूचकांक है।
मुझे लगता है, कि एन्युमरेट से बचने का एक तरीका होना चाहिए। सूचकांक द्वारा सीधे इनपुट सरणी तक पहुँचने की तरह [ n[len(locals()['_[1]'])+sum(locals()['_[1]'])] for ... ]:। लेकिन मैं इसे इंडेक्स-आउट-ऑफ-रेंज (इसे ऑनलाइनर रखते हुए) से बचाने के लिए एक कॉम्पैक्ट तरीका नहीं समझ सकता

यहाँ छवि विवरण दर्ज करें

— मृत पोसुम
स्रोत
1

स्विफ्ट, 63 बाइट्स

func a(d:[Int]){var i=0;while i<d.count{print(d[i]);i+=d[i]+1}}

यह मेरी पहली प्रविष्टि है, कभी भी, इसलिए मुझे नियमों पर 100% यकीन नहीं है, लेकिन उम्मीद है कि यह जवाब पर्याप्त है। मैं कैसे एक प्रणाली में इनपुट पाने के लिए नियमों का थोड़ा अनिश्चित हूँ। मेरे पास एक छोटा जवाब है अगर मुझे एक फ़ंक्शन को मानने की अनुमति दी गई थी जो इनपुट वापस कर सकती है।

— AnonymousReality
स्रोत
PPCG में आपका स्वागत है! डिफ़ॉल्ट नियम यह है कि आपके पास या तो कोड हो सकता है जो एक पूर्ण कार्यक्रम के रूप में काम करता है, इसलिए इनपुट (आमतौर पर) STDIN में और आउटपुट (आमतौर पर) STDOUT, या किसी फ़ंक्शन के लिए, इसलिए इनपुट (आमतौर पर) फ़ंक्शन मापदंडों और आउटपुट से (आमतौर पर) समारोह वापसी।
— स्टीफन
@ स्टेफ़ेन - धन्यवाद! मुझे लगता है कि मेरे अन्य संस्करण को तब अमान्य बना देता है। अधिक योगदान के लिए आगे देख रहे हैं!
— AnonymousReality
1

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

{(@_,{.[1+.[0]..*]}...^0)[*;0]}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit parameter ｢@_｣
  (
    # generate a sequence

    @_,

    {
      .[ # index into previous value in the sequence
        1 + .[0]  # start by skipping one plus the first element
                  # of the previous value in the sequence
        ..  *     # use that to create a Range with no end
      ]
    }

    ...^  # keep doing that until: (and throw away last value)
    0     # it generates an empty list

  )[ *; 0 ]  # from every value in the sequence, get the first element
}

यह समझने में मदद करने के लिए कि कोड कैसे काम करता है, इसके बिना [*;0]निम्नलिखित की तरह एक अनुक्रम उत्पन्न होगा:

[0, 1, 0, 2, 5, 1, 3, 1, 6, 2],
   (1, 0, 2, 5, 1, 3, 1, 6, 2),
         (2, 5, 1, 3, 1, 6, 2),
                  (3, 1, 6, 2)
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

जेली , 8 बाइट्स

ḢṄ‘ṫ@µL¿

एक नयालाइन (खाली सूची कोई उत्पादन नहीं करता है) के बाद प्रत्येक परिणाम को मुद्रित करने वाला एक पूरा कार्यक्रम।

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

कैसे?

ḢṄ‘ṫ@µL¿ - Main link: list of non-negative integers  e.g. [2,5,4,0,1,2,0]
       ¿ - while:           Iteration:  1                  2             3          4        5
      L  -   length (0 is falsey)       7                  4             3          1        0
     µ   - ...do:                                                                            stop
Ḣ        -   head (pop & modify)        2 ([5,4,0,1,2,0])  0 ([1,2,0])   1 ([2,0])  0 ([0])
 Ṅ       -   print it (and yield it)   "2\n"              "0\n"         "1\n"      "0\n"
  ‘      -   increment                  3                  1             2          1
   ṫ@    -   tail from index            [0,1,2,0]          [1,2,0]      [0]         []
         -
         -                       i.e. a resulting in the printing of: '''2
                                                                         0
                                                                         1
                                                                         0
                                                                         '''
— जोनाथन एलन
स्रोत
अंत में एक जेली जवाब! BTW मैं इसे 7 बाइट्स में कर सकता हूं।
— आउटगोल्फ जूल
और मेरे पास 18 बाइट्स में एक सूची-वापसी फ़ंक्शन भी है।
— आउटगोल्फ जूल
1

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

f=lambda h=0,*t:t and[h,*f(*t[h:])]

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

साथ इसे चलाने f(*l)जहां lअपने इनपुट है। यकीनन इनपुट के लिए नियमों को लंबा करना, लेकिन मैं सिर्फ उन्नत अनपैकिंग से प्यार करता हूं।

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