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

Erik the Outgolfer 08/26/2017. 30 answers, 2.887 views
code-golf array-manipulation

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


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

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

नियम

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

टेस्ट केस

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

यह , इसलिए सबसे छोटा जवाब जीतता है!

5 Comments
Erik the Outgolfer 07/28/2017
सैंडबॉक्स (केवल 2k + उपयोगकर्ता)
3 Shaggy 07/28/2017
हाँ, बस इसे देखा। / चश्मा रखता है
2 Rod 07/28/2017
शायद एक leprechaun ¯ \ _ (ツ) _ / ¯
1 Roman Gräf 07/28/2017
क्या मेरे सरणी में पिछला शून्य होना ठीक है? मुझे ~ 18 बाइट बचाएगा
1 Erik the Outgolfer 07/28/2017
@ RomanGräf क्षमा करें लेकिन नहीं, यह बहुत संदिग्ध होगा क्योंकि ऐसे मामले हैं जिनके पास आउटपुट में 0 पीछे पीछे होना चाहिए।

30 Answers


Rod 07/28/2017.

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

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

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

4 comments
Mr. Xcoder 07/28/2017
मैं बाहर निकलने की उम्मीद कर रहा था, लेकिन बुरी तरह से नहीं :)
Erik the Outgolfer 07/28/2017
क्या आप x[0] बजाय x[0] नहीं कर सकते?
Rod 07/28/2017
@EriktheOutgolfer हाँ, लेकिन इसे एक सूची होने की आवश्यकता है, तो यह [x[0]]
Erik the Outgolfer 07/28/2017
@Rod आप x[:1] वैसे भी किसी भी बाइट्स को सहेज नहीं रहे हैं ... f=lambda x:x and[x[0]]+f(x[x[0]+1:])

Mr. Xcoder 08/19/2017.

पायथन 2 , 4 9 46 * 41 बाइट्स

क्रॉस्ड आउट 4 अभी भी नियमित है 4 :(

* -3 thanks to @ASCII-only

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

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

ओपी को चैट में अनुमति के रूप में, एक नई लाइन से अलग परिणामों को मुद्रित करता है। मुझे नहीं लगता कि यह एक non-recursive full program रूप में कम हो सकता है।


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

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

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

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

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

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

सूची के रूप में सूची [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 मुद्रित है और कार्यक्रम समाप्त हो जाता है।

1 comments

w0lf 07/28/2017.

हास्केल, 2 9 27 26 बाइट्स

 j(x:y)=x:j(drop x y)
j x=x 

Zgarb को 1 बाइट धन्यवाद बचाया।

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

2 comments
Zgarb 07/28/2017
दूसरी पंक्ति पर f x=x एक बाइट बचाता है।
w0lf 07/28/2017
@Zgarb कूल, धन्यवाद!

Adnan 07/28/2017.

05AB1E , 10 9 बाइट्स

[¬Dg>#=ƒ¦ 

05AB1E एन्कोडिंग का उपयोग करता है। इसे ऑनलाइन आज़माएं!

1 comments
Magic Octopus Urn 07/28/2017
हाँ, यह वही तरीका है जो मैं सोच रहा था उससे बेहतर है।

Martin Ender 07/28/2017.

गणित, 46 44 बाइट्स

SequenceCases[#,NO 

विकल्प:

SequenceCases[#,NO 
1 comments
Mr.Wizard 07/28/2017
वाह, यह बहुत अच्छा है!

Johan Karlsson 07/28/2017.

जावास्क्रिप्ट (ईएस 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 bytes thanks to @ThePirateBay

1 comments
ThePirateBay 07/28/2017
39 बाइट्स a=>a.map(n=>i--||r.push(i=n),r=i=[])&&r

TheLethalCoder 07/28/2017.

सी #, 68 बाइट्स

 a=>{for(int i=0;i 

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

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

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

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

            Console.ReadLine();
        }
    }
} 

सूची लौटने पर 107 बाइट्स पर लंबा समय लगता है।

 a=>{var l=new System.Collections.Generic.List();for(int i=0;i 
3 comments
2 TheLethalCoder 07/28/2017
किसी ने इसे क्यों कम किया है?
Thomas Ayoub 07/31/2017
अपने स्कोर को गोल करने और एकदम सही 5k बनाने के लिए?
TheLethalCoder 07/31/2017
@ थॉमसएयूब हम केवल यह मान सकते हैं कि यह ओसीडी हां वाला कोई व्यक्ति था।

Zgarb 07/28/2017.

हुस्क , 8 6 बाइट्स

←TU¡Γ↓ 

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

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

व्याख्या

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

←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] 
5 comments
Leo 07/28/2017
आप ø के डिफ़ॉल्ट मान को छोड़ सकते हैं, और सबकुछ अभी भी जादुई रूप से काम करेगा :)
Leo 07/28/2017
या, यहां तक ​​कि कम बाइट्स के लिए, tio.run/##yygtzv7//1HbhJDQQwvPTX7UNvn////RBjpGOiBsomOoYxQLAA
Zgarb 07/28/2017
@ लेओ ओह वाह, यह चालाक है!
Erik the Outgolfer 07/28/2017
आपने सीडब्ल्यू क्यों किया?
Zgarb 07/28/2017
@ErikTheOutgolfer यह एक गलती थी (मैं अपने फोन पर हूं और स्पष्ट रूप से दुर्घटना से कुछ धक्का दिया)। मैं इसे पूर्ववत करने की कोशिश कर रहा हूं ...

Ruud 07/28/2017.

पायथन 2 , 5 9 55 बाइट्स

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

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

2 comments
1 Rod 07/28/2017
आप l[i:i+l[i-1]]=[] इसके बजाय del l[i:i+l[i-1]] का उपयोग कर सकते हैं बाइट को बचाने के लिए

Dave 07/28/2017.

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

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

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

4 comments
Erik the Outgolfer 07/28/2017
मैं वहां 23 बाइट्स देखता हूं।
Dave 07/28/2017
Typo :) क्षमा करें ...
3 Wheat Wizard 07/28/2017
मुझे यकीन नहीं है कि आपके पास नीचे वोट क्यों है। एक संभावना है कि जब आप अपने उत्तर को ठीक करने के लिए संपादित करते हैं तो इसने "स्वचालित डाउन वोट" शुरू किया। इस स्वचालित डाउनवोट के कारण भ्रमित और भयानक हैं लेकिन यह तब होता है जब सिस्टम आपके उत्तर को हेरिस्टिक्स के आधार पर "कम गुणवत्ता" मानता है। यह भी संभव है कि किसी को आपका जवाब पसंद न आए, लेकिन मुझे इस समय कुछ भी गलत नहीं दिख रहा है, इसलिए मुझे यकीन नहीं है कि ऐसा क्यों होगा।
isaacg 07/31/2017
मुझे खुशी है कि आप पाइथ का उपयोग कर रहे हैं!

Rod 07/28/2017.

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

-18 बाइट्स लुइस मेंडो के लिए धन्यवाद

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

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


Martin Ender 07/28/2017.

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

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

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

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

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


Riley 07/28/2017.

मस्तिष्क-फ्लाक , 64 बाइट्स

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

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

([]){{}                          ([])}{}                         # Until the stack is empty
       (({})<>)<>                                                # Copy TOS to off stack
                 {({}[()]<{}>)}{}                                # Pop TOS times
                                        <>([]){{}({}<>)<>([])}<> # Reverse off stack 
2 comments
6 DJMcMayhem 07/28/2017
पवित्र बकवास! मैंने एक समाधान लिखा, और फिर इसे पोस्ट करने के लिए नीचे स्क्रॉल किया, लेकिन यह पता चला कि हमने एक ही समाधान को बाइट-फॉर-बाइट लिखा था! यहां तक ​​कि मामूली विवरण जैसे ({}[()]<{}>) बनाम ({}<{}>[()]) वही थे! क्या एक संयोग है!
2EZ 4RTZ 07/28/2017
@DJMcMayhem सभी प्रसिद्धि एक्सडी चोरी

user202729 07/28/2017.

गणित, 64 50 बाइट्स

±x_List:=Prepend[±Drop[x,1+#&@@x],#&@@x]
±_=±{}={} 
1 comments
Mr.Wizard 07/28/2017
मैं इस साफ कोड को और गोल्फ़िंग का विरोध नहीं कर सका; मेरा जवाब नीचे है।

jkelm 07/28/2017.

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

 n=>{var t="";for(int i=0;i 

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

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

3 comments
TheLethalCoder 07/28/2017
ऐसा करने का अच्छा तरीका है और प्रिंटिंग के समान गणना में आता है।
jkelm 07/28/2017
मुझे सरल समाधान पसंद हैं। फिर भी LINQ सीखना होगा, जैसा कि मैंने देखा है कि इतने सारे c # lambdas को छोटा करें ..
TheLethalCoder 07/28/2017
इसे छोटा करता है क्योंकि आप अधिकतर समय में वापसी का अनुमान लगा सकते हैं। हालांकि यह using System.Linq; साथ अंतर्निहित वापसी के बीच टॉस अप है using System.Linq; और एक सामान्य पाश।

Jarko Dubbeldam 07/28/2017.

आर, 58 बाइट्स

f=function(x,p=1)NO 

रिकर्सिव फ़ंक्शन। एक वेक्टर x को तर्क के रूप में लेता है और एक सूचक p intiates। यह 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]))) 

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

3 comments
Giuseppe 07/28/2017
numeric(0) इनपुट के बारे में क्या? उर्फ खाली सरणी।
Jarko Dubbeldam 07/28/2017
@ जीयूसेपे मैं अपने पीसी के पीछे हूं जब मैं इसे देख लूँगा
Giuseppe 08/24/2017
57 बाइट्स! और यह खाली मामले को भी संभालता है।

Roman Gräf 07/28/2017.

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

@ PunPun1000 और @TheLethalCoder के लिए धन्यवाद

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

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

5 comments
TheLethalCoder 07/28/2017
परिणामों को प्रिंट करना, जैसे कि मेरे सी # उत्तर में, आपको कुछ भी बचाओ?
Roman Gräf 07/28/2017
@TheLethalCoder बीमार कोशिश करो
TheLethalCoder 07/28/2017
क्या आप लूप में n को स्थानांतरित करके बाइट बचा सकते हैं?
TheLethalCoder 07/28/2017
इसके अलावा इस समय काम नहीं लग रहा है।
PunPun1000 07/28/2017
आप (a[n+=1+a[n]] बाद एक माता पिता को याद कर रहे हैं। सही मूल्य को आउटपुट करने के बाद फ़ंक्शन भी एक त्रुटि फेंकता है, मुझे इस बात की सहमति नहीं है कि यह अनुमति है या नहीं (सवाल करता है मानक त्रुटि के लिए कुछ भी कहें अनदेखा किया जाता है)। यदि वह इरादा था, तो आप लूप के लिए n को हटा सकते हैं। अंत में n कोड जैसा नहीं है, यहां तक ​​कि n साथ भी। कार्य होना चाहिए एक Consumer और func.accept(test) उपयोग करें

Martin Ender 07/28/2017.

एलिस , 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 मान पढ़ेंगे, जिनमें से अंतिम स्टैक के शीर्ष पर समाप्त हो जाएगा। यह आवश्यक संख्या सूची तत्वों को छोड़ देता है।


Mr.Wizard 07/28/2017.

Mathematica , 37 (30?)

उपयोगकर्ता 20272 9 की बढ़िया विधि के आगे गोल्फ़िंग।

±NO 

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

±NO 

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

2 comments
1 JungHwan Min 07/28/2017
±Drop[NO ±NO क्योंकि ± में Infix तुलना में कम प्राथमिकता है।
Mr.Wizard 07/28/2017
@JungHwanMin मुझे याद आया; धन्यवाद!

Jenny_mathy 07/28/2017.

गणित, 65 बाइट्स

(s=#;t=1;w={};While[t<=Length@s,AppendTo[w,k=s[[t]]];t=t+k+1];w)& 

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


w0lf 07/28/2017.

रुबी, 36 33 31

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

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

4 comments
sethrin 07/30/2017
आपको f= को हेडर तत्व के रूप में घटाने की अनुमति है।
w0lf 07/30/2017
@sethrin भले ही मुझे इसे दोबारा कॉल करने की ज़रूरत है?
sethrin 07/30/2017
हम्म, अच्छा सवाल है। मुझे नहीं लगता। मैंने आपके समाधान के बारे में बहुत कुछ किया, वैसे भी।
w0lf 07/30/2017
@ सेथ्रिन धन्यवाद! :)

AnonymousReality 07/28/2017.

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

func a(d:[Int]){var i=0;while i 

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

2 comments
Stephen 07/28/2017
पीपीसीजी में आपका स्वागत है! डिफ़ॉल्ट नियम यह हैं कि आपके पास या तो कोड हो सकता है जो एक पूर्ण प्रोग्राम के रूप में काम करता है, इसलिए एसटीडीआईएन में इनपुट (आमतौर पर) और आउटपुट (आमतौर पर) एसटीडीओयूटी, or फ़ंक्शन के लिए, इसलिए फ़ंक्शन पैरामीटर और आउटपुट (आमतौर पर) से इनपुट (आमतौर पर) समारोह वापसी
AnonymousReality 07/28/2017
@StepHen - धन्यवाद! मुझे लगता है कि मेरा दूसरा संस्करण अमान्य बनाता है। अधिक योगदान करने के लिए तत्पर हैं!

पर्ल 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) 

Renzo 07/29/2017.

सामान्य लिस्प, 51 बाइट्स

(do((x(read)(nthcdr(1+(print(car x)))x)))((not x))) 

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


सी ++ (जीसीसी), 172 बाइट्स

#includeint main(){std::istream& i=std::cin;char c;int a,b;while(i>>c&&i>>a){std::cout<>c&&i>>b);}std::cout< 

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

भयानक (c/91?"":" ") आउटपुट में सही अंतर के लिए है। इसके बिना (-15 बाइट्स) आउटपुट फॉर्म में है: [0,2,4] , जब मैं इसे सरल " " (-9 बाइट्स) आउटपुट में बदलता हूं तो [ 0, 2, 4] (शुरुआत में अतिरिक्त स्थान) जैसा होता है ।

<<(c/93?"":"]") अंत में केवल [] खाली इनपुट कोने केस को संभालने के लिए है

कोई पीछे की समाप्ति अंतराल मुद्रित करता है।

1 comments
Erik the Outgolfer 07/30/2017
आप नो-डिजिट सेपरेटर द्वारा अलग संख्याओं को भी प्रिंट कर सकते हैं, [] आवश्यकता नहीं है और आप उस एज-केस के लिए खाली आउटपुट प्राप्त कर सकते हैं, और इसकी आवश्यकता नहीं है (c/91?"":" ") । आपको चुनौती में उदाहरणों के प्रारूप से मेल नहीं करना पड़ेगा।

Jonathan Allan 07/29/2017.

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

ḢṄ‘ṫ@µL¿ 

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

Try it online!

कैसे?

ḢṄ‘ṫ@µ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
                                                                         ''' 
2 comments
Erik the Outgolfer 07/30/2017
अंत में एक जेली जवाब! बीटीडब्ल्यू मैं इसे 7 बाइट्स में कर सकता हूं।
Erik the Outgolfer 07/30/2017
और मेरे पास 18 बाइट्स में एक सूची-वापसी समारोह भी है।

Evpok 07/30/2017.

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

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

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

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


cliffroot 07/28/2017.

क्लोजर, 67 बाइट्स

#(nth(reduce(fn[[z k]b](if(= z 0)[b(conj k b)][(- z 1)k]))[0[]]%)1) 

प्रारंभिक मानकों के साथ शुरू होता है [0 []] , जहां 0 काउंटर है और [] परिणाम है। यदि इस सूची में पहला तत्व 0 तर्क से परिणाम n को जोड़ता है और इस सूची को आगे भेजता है [n [... n]] अन्यथा पहले तत्व को कम करता है। (यह स्पष्टीकरण मेरे लिए भयानक लगता है)

इसे ऑनलाइन देखें


Dead Possum 07/28/2017.

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

इसके साथ अजगर में जीतने का कोई मौका नहीं है, लेकिन मुझे ऑनलाइनर पसंद हैं और यह दूसरों के लिए दिलचस्प हो सकता है।
बाहर निकलता है, समझ के अंदर बिल्डिंग सूची तक पहुंचने के लिए एक फैंसी जादू चाल है, लेकिन यह केवल 2.4 में काम करता है और कुछ संपादन <= 2.3 में
locals()['_[1]'] यह है। पाइथन सूची के लिए गुप्त नाम _[1] बनाता है, जबकि इसे बनाया जाता है और इसे locals में संग्रहीत किया जाता 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 ... ] । लेकिन मैं इसे इंडेक्स-ऑफ-रेंज से बचाने के लिए एक कॉम्पैक्ट तरीका नहीं समझ सकता (इसे ऑनलाइनर रखते हुए)

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


Neil 07/28/2017.

बैच, 69 बाइट्स

:l
@if not "%1"=="" echo %1&(for /l %%i in (0,1,%1)do @shift)&goto l 

(मुझे लूप के अंदर goto होता है अन्यथा इसके for () एस की आवश्यकता होती है।)

Related questions

Hot questions

Language

Popular Tags