पहले 1 बनें (केवल पहले सत्य को छोड़ें)

Question

पहचान

हर साल, Dyalog Ltd. एक छात्र प्रतियोगिता आयोजित करता है। वहां चुनौती है कि अच्छा एपीएल कोड लिखना है । यह इस साल की आठवीं समस्या का एक भाषा अज्ञेयवादी कोड-गोल्फ संस्करण है।

मुझे प्रतियोगिता के मूल लेखक से इस चुनौती को पोस्ट करने की स्पष्ट अनुमति है। दिए गए लिंक का पालन करके और लेखक से संपर्क करके स्वतंत्र महसूस करें ।

मुसीबत

एक बूलियन * सूची को देखते हुए, पहले सत्य के बाद सभी सत्य को "बंद" करें।

कोई सच्चाई नहीं? कोई दिक्कत नहीं है! बस सूची को बिना बताए वापस कर दें।

उदाहरण

[falsy,truthy,falsy,truthy,falsy,falsy,truthy] → [falsy,truthy,falsy,falsy,falsy,falsy,falsy]

[] → []

[falsy,falsy,falsy,falsy] → [falsy,falsy,falsy,falsy]

---

* आपके सभी सत्य समान होने चाहिए, और आपके सभी झूठ समान होने चाहिए। इसमें आउटपुट शामिल है।

Comments

क्या हम बिट सूचियों या अन्य सत्य / झूठी सूची अभ्यावेदन का उपयोग कर सकते हैं जो हमारी पसंद की भाषा में अधिक स्वाभाविक हैं?

— मार्टिन एंडर

हाँ, अगर आप "सच" और "झूठे" के बारे में बात करते हैं तो चुनौती में "बूलियन्स", "सच" और "झूठे" के बजाय। ;)

— मार्टिन एंडर

मैं बूलियन्स पर स्पष्ट नहीं हूं। क्या हम 0/1 का उपयोग कर सकते हैं, भले ही हमारी भाषा सच / गलत हो?

— xnor

@xnor आह, अच्छी बात है। मुझे लगता है कि इनपुट चुनने की अनुमति देना उचित होगा, लेकिन आउटपुट मैच होना चाहिए, क्या आपको ऐसा नहीं लगता?

— '21:

@xnor मैं आपको सुनता हूं, लेकिन अगर हास्केल बूलियन के रूप में संख्याओं का इलाज नहीं कर सकता है, या बुलियन पर अंकगणित नहीं कर सकता है, तो वह हास्केल की गोल्फ की शक्ति में एक वास्तविक सीमा है, और बाइट काउंट में रूपांतरणों या अन्य काम की आवश्यकता को प्रतिबिंबित किया जाना चाहिए। -arounds। फुटनोट फॉर्म्युलेशन से आप क्या समझते हैं?

— एडम

Answer 1

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

while 1:b=input();print b;True&=b<1

इसे ऑनलाइन आज़माएं! इनपुट और आउटपुट ट्रू / फाल्स की लाइनें हैं।

डेनिस के समाधान पर आधारित है । किसी इनपुट के सामने आने के बाद वेरिएबल Trueको फिर से परिभाषित करता है। इस तरह, आगे के किसी भी इनपुट का मूल्यांकन और इस तरह से मुद्रित किया जाएगा।FalseTrueTrueFalse

पुनर्वित्त है True&=b<1, अर्थात True = True & (b<1)। जब इनपुट bहोता है True, तो (b<1)गलत (तब से True==1) है, इसलिए Trueबन जाता है False।

Comments

तुम सच को फिर से परिभाषित कर सकते हैं ??? यह एक योग्य है, क्योंकि hax> _>

— HyperNeutrino

@ हायपरनेट्रिनो हाँ, लेकिन पाइथन 3 में नहीं। (जो कि ठीक है क्योंकि यहाँ की भाषा पाइथन 2 है।)

— ब्रायन मैककियॉन

@BrianMcCutchon ठीक है धन्यवाद। हालांकि यह अजीब है ...

— हाइपरयुट्रीनो

@ हैपरनेट्रिनो यह संभवतः ध्यान देने योग्य है कि आप कर सकते हैं True, False = False, True।

— ब्रायन मैककचून

@ हाइपर न्यूट्रिनो - नहीं। बिलिंस अभी भी 'वास्तविक' मान लौटाते हैं, यह सिर्फ 'सही' है जो आप टाइप करते हैं। (या मॉड्यूल, कुछ मामलों में ...)। इसलिए बूल (1) ट्रू रिटर्न, लेकिन बूल (1) == ट्रू रिटर्न फाल्स।

— टीएलडब्ल्यू

Answer 2

एपीएल , 2 बाइट्स

<\

फ़ंक्शन का मूल्यांकन "कम-से-कम का उपयोग करके स्कैन करें"। इसे ऑनलाइन आज़माएं!

व्याख्या

एपीएल में, ऑपरेटर \(स्कैन) प्रदान किए गए फ़ंक्शन का उपयोग करके दाईं ओर से किसी सरणी के प्रत्येक गैर-रिक्त उपसर्ग को कम करता है। उदाहरण के लिए, सरणी को देखते हुए 0 1 0, यह गणना करता है 0(लंबाई 1 का उपसर्ग), 0<1(लंबाई 2 का उपसर्ग) और 0<(1<0)(लंबाई 2 का उपसर्ग) और परिणामों को एक नए सरणी में रखता है; कोष्ठक दाईं ओर जुड़ता है। सरणी के अंतिम तत्व और बाकी हिस्सों <के सही होने पर सही परिणामों से कम करना , इसलिए बाईं ओर स्थित उपसर्ग को और दूसरों को कम कर दिया जाता है ।110110

Comments

आखिरकार! मैं सोच रहा था।

— '10

अब मुझे लगता है कि आप जम्मू में भी जवाब दे सकते हैं, नहीं?

— '10:

@ Adám हां, J में यह 3 बाइट्स है: </ \ Jelly में शायद एक अनुरूप 2-बाइट समाधान भी है।

— जर्ग्ब

नहीं, मुझे ऐसा नहीं लगता, क्योंकि जेली बाएं से दाएं है।

— '10:38

आपको अलग-अलग पोस्ट के रूप में अलग-अलग भाषा उत्तर पोस्ट करने चाहिए।

— '10

Answer 3

एसिटो , 19 17 बाइट्स गैर-प्रतिस्पर्धात्मक

नया संस्करण (17 बाइट्स):

यह नया संस्करण पात्रों को एक बार में लेता है और -Fविकल्प के साथ सबसे अच्छा निष्पादित होता है। यह समान काम करता है, लेकिन पिछले समाधान के समान नहीं है:

 >,
Op0
p|1u
,ip^

---

पुराना उत्तर (19 बाइट्स):

(गैर-प्रतिस्पर्धा क्योंकि मुझे दुभाषिया में दो कीड़े को ठीक करना पड़ा)

|p1u
iOp<
|!`X
rd!r

यह पहला एसेटो उत्तर है जो इस पर प्रकाश डालता है कि यह अपेक्षाकृत अच्छा क्या कर सकता है, मैं कहूंगा। "सूचियाँ" इनपुट स्ट्रीम हैं, प्रति पंक्ति एक इनपुट के साथ, "1" सत्य के लिए, और "0" असत्य के लिए, खाली स्ट्रिंग सूची के अंत को दर्शाता है।

एकेटो प्रोग्राम एक हिल्बर्ट वक्र पर चलता है, जो नीचे बाईं ओर से शुरू होता है, और नीचे दाईं ओर समाप्त होता है। सबसे पहले, हम rएक स्ट्रिंग, dअपलिडेट, और नेगेट ( !) करते हैं, इसे खाली स्ट्रिंग्स को ट्रू में बदल देते हैं, बाकी सब कुछ फाल्स में। फिर एक सशर्त क्षैतिज दर्पण ( |) है: यदि स्टैक पर शीर्ष तत्व सत्य है, क्षैतिज रूप से दर्पण। यह तब होता है जब स्ट्रिंग खाली थी। यदि हम मिररिंग करते हैं, तो हम उस पर उतरते हैं X, जो दुभाषिया को मारता है।

अन्यथा, हम स्टैक पर शेष प्रतिलिपि को एक iनेगर में परिवर्तित करते हैं और एक और सशर्त क्षैतिज दर्पण करते हैं: इस बार, क्योंकि 1 सत्य है और 0 मिथ्या है, हम दर्पण देखते हैं यदि हम (प्रथम) सत्य मान देखते हैं। यदि हम दर्पण नहीं करते हैं (इसलिए हमने एक 0 देखा) तो हम pबताते हैं कि स्टैक पर क्या है (चूंकि स्टैक खाली है, एक शून्य) और Oवक्र की कठोरता पर कूदें, जहां हमने शुरू किया, पूरी प्रक्रिया को फिर से शुरू करना।

अन्यथा, जब हमने 1 देखा, हम दर्पण और जमीन पर u, जो कि हम हिल्बर्ट वक्र पर जाने वाली दिशा को उलट देते हैं। 1pएक 1 प्रिंट करता है, और अब हम उसी पर जाते हैं Oयदि हम 0 पर दिखाई देते थे, तो हम चले गए थे, लेकिन जब से हम "उलट मोड" में हैं, तो हमारा मूल नीचे दाईं ओर है , इसलिए हम वहां कूदते हैं।

अब हम rएक और स्ट्रिंग का उपयोग करते हैं, और इसे नकारात्मक करते हैं। यदि स्ट्रिंग खाली थी, और इसलिए शीर्ष स्टैक तत्व सत्य है, तो अगले कमांड ( ) `से नहीं बचेंगे X, जिससे हम पद छोड़ देंगे ।

अन्यथा (यदि स्ट्रिंग खाली नहीं थी), हम इसे से बचते हैं Xऔर इसे अनदेखा करते हैं। उस स्थिति में, हम बाईं ओर जाते हैं ( <), print 0 (क्योंकि स्टैक खाली है), और Oरिगिन पर वापस कूदें।

Comments

Aceto में हल की गई आपकी पहली उचित चुनौती के लिए बधाई।

— '21

आरेख पर दिखता है। ठीक है ...

— एडम

@ Adám यह शायद मदद नहीं करेगा (यदि आप Aceto को नहीं जानते हैं), लेकिन मैंने सोचा कि पाठ के साथ-साथ इसे बेहतर तरीके से पालन करने में सक्षम होना अच्छा होगा।

— L3viathan

Answer 4

जावा 8, 24 19 बाइट्स

Long::highestOneBit

आशा है कि यह कानूनी है; मुझे आभास हुआ कि भाषा में इनपुट / आउटपुट का सही / गलत मूल्यांकन नहीं होता है। एक लंबे इनपुट के रूप में लेता है और आउटपुट के रूप में एक देता है, जो कि सच है और शून्य बाइनरी प्रतिनिधित्व में झूठा है। उदाहरण के लिए, बाइनरी 00101 5 है और बाइनरी 00100 जो 4 है।

@ ब्यूहलेन को पांच बाइट्स धन्यवाद

Comments

अच्छा तरीका। जावा प्रतिस्पर्धी हो रहा है

— '11:04

वाह, JAVA एक प्रतियोगी उत्तर के रूप में

— Zacharý

पूरी तरह से यकीन नहीं है कि अगर यह कोडगुल्फ नियमों के लिए मान्य है, लेकिन इसे विधि संदर्भ का उपयोग करके 19 वर्णों में सुधार किया जा सकता है: Long::highestOneBitजो एक छोटे वाक्यविन्यास के साथ समान परिणाम उत्पन्न करता है

— puhlen

अनाम कार्यों का मूल्यांकन करने वाले @puhlen अभिव्यक्ति की अनुमति है।

— साइओस

@NathanMerrill java.langपैकेज डिफ़ॉल्ट रूप से आयात किया जाता है। से भाषा कल्पना "एक संकलन इकाई स्वचालित रूप से सभी प्रकार के लिए उपयोग अपने पैकेज में घोषित कर दिया और भी स्वतः ही सार्वजनिक प्रकार के सभी पूर्वनिर्धारित पैकेज java.lang में घोषित आयात करता है।"

— जॉली जोकर

Answer 5

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

1>`1
0

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

इनपुट 0एस (झूठी के लिए) और 1एस (सत्य के लिए ) की एक सूची है ।

सभी से मेल खाता है 1और पहले वाले को छोड़कर प्रत्येक को बदल देता है ( 1>) a के साथ 0।

Comments

अब हम इसे देख सकते हैं। आप कुछ OS पर एक कार्यालय में काम कर रहे हैं। एक प्रबंधक आता है और regex के साथ एक संपूर्ण OS लिखने के लिए आप पर चिल्लाता है।

— क्रिस्टोफर

Answer 6

वी , 7 बाइट्स

f1òf1r0

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

मेरा पहला V सबमिशन! \ O /

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

f1òf1r0
f1       "go to the next occurence of 1
  ò      "repeat the following until end:
   f1    "    go to the next occurence of 1
     r0  "    replace with 0

Comments

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

— ब्रायन मैक्च्यूटन

@BrianMcCutchon स्पष्टीकरण जोड़ा गया।

— लीक नून

यह पहली स्थिति में 1 के लिए विफल रहता है :(

— nmjcman101

@ nmjcman101 तय।

— लीक नून

जब से तुम इनपुट प्रारूप बदल गया है, आप स्वैप कर सकते हैं r0के साथ <C-x>लोगों घटती और एक बाइट को बचाने के लिए।

— nmjcman101

Answer 7

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

बेनामी फ़ंक्शन लेने और उनकी सूची वापस करने के लिए Bool।

के रूप में उपयोग करें (foldr(\x l->x:map(x<)l)[])[False,True,False,False]।

foldr(\x l->x:map(x<)l)[]

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

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

• दाएं से एक सूची में सिलवटों, नए तत्वों का शिकार करना और संभवतः उन लोगों को संशोधित करना।
• xसबलिस्ट में शामिल होने का तत्व है l।
• वे उपयोग जो Falseकम से कम तुलना True, इसलिए map(x<)lकिसी भी बदल जाएगी Trueमें रों lमें Falseअगर xहै True।

Answer 8

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

+\=a

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

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

व्याख्या

+\=a
+\    Cumulative sum of the input list
  =   Compare corresponding elements with the input
   a  Logical AND corresponding elements with the input

जब तक किसी तत्व के बाईं ओर सभी तत्व 0 होते हैं, तब तक किसी तत्व का संचयी योग तत्व के बराबर होगा। पहले 1 के दाईं ओर, दोनों अलग-अलग हैं (क्योंकि अब हम तत्वों के नॉनज़रो को बाईं ओर जोड़ रहे हैं)। इस प्रकार, +\=हमें 1 सत्य (सत्य) युक्त सूची देता है और पहले सत्य तत्व को शामिल करता है। अंत में, तार्किक और मूल सूची के साथ हमें केवल 1 पहला सत्य तत्व देगा।

Answer 9

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

a=>a.map(e=>e&!(i-=e),i=1)

I / O 0s और 1s के सरणियों में है।

Answer 10

05AB1E , 6 बाइट्स

कोड:

ā<s1kQ

स्पष्टीकरण:

ā         # External enumeration, get a and push [1 .. len(a)]
 <        # Decrement each
  s       # Swap to get the input
   1k     # Get the first index of 1
     Q    # Check for equality with the enumeration array

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

Comments

1k>sƶ-_एक और है, हालांकि बदतर है। liftविचार संभावित हालांकि हो सकता है।

— मैजिक ऑक्टोपस Urn

Answer 11

ट्यूरिंग मशीन सिम्युलेटर , 39 बाइट्स

0 0 0 r 0
0 1 1 r 1
1 0 0 r 1
1 1 0 r 1

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

Comments

अनिवार्य रूप से वही बात जो मैं अपने उत्तर में कर रहा हूं।

— L3viathan

Answer 12

ब्रेनफक , 55 बाइट्स

+>,[[->+>[->-<]>+[-<+>]<<<]>>[-<-<<[->>+<<]>>>]<.[-]<,]

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

Answer 13

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

मेरे 05AB1E उत्तर का एक बंदरगाह।

i1=J

स्पष्टीकरण (तर्क α ):

i1        # Index of 1 (1-indexed) in α
  =       # Check for equality with the array:
   J      # [1 .. len(α)]

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

Answer 14

आर , 24 बाइट्स

cumsum(T<-scan(,F))==T&T

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

उदाहरण:

इनपुट FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tरिटर्न के लिए TRUE TRUE FALSE FALSE। स्कैन में F तार्किक इनपुट सुनिश्चित करता है।
FALSE TRUE TRUE FALSEऔर TRUE TRUE FALSE FALSEहै FALSE TRUE FALSE FALSE। एक एकल &एक तत्वपूर्ण तुलना करता है।

Comments

@rturnbull दुर्भाग्य से इनपुट प्रारूप आउटपुट के समान होना चाहिए।

— मिकी

Answer 15

ऑक्टेव, 23 बाइट्स

@(a)diff([0 cummax(a)])

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

सूची के संचयी अधिकतम का पहला अंतर।

Answer 16

जे , 3 बाइट्स

</\

एक राक्षसी क्रिया को परिभाषित करता है। यह मेरे एपीएल उत्तर का एक तुच्छ बंदरगाह है । इसे ऑनलाइन आज़माएं!

Answer 17

पायथन, 58 बाइट्स

lambda x:[x[i]and x.index(x[i])==i for i in range(len(x))]

यदि x[i]गलत है, तो आउटपुट झूठा है; अन्यथा, यह देता है कि तत्व स्वयं की सरणी में पहली घटना है या नहीं।

Answer 18

PHP, 37 बाइट्स

foreach($_GET as$v)echo$v*!$$v++,' ';

Answer 19

पर्ल 5, 20 बाइट्स

sub{map$_&&!$x++,@_}

सत्य है 1और मिथ्या है ''(एक रिक्त स्ट्रिंग)।

स्पष्टीकरण:

mapसूची के तत्वों पर लूप्स @_, यह सबरूटीन को दिए गए तर्क, प्रत्येक तत्व को $ _ स्थानीय रूप से सेट करते हैं और रिटर्न मानों की एक सरणी लौटाते हैं जो प्रत्येक तत्व से गणना करता है। अगर यह सच है और यह सत्य है तो $_&&!$x++आउटपुट । (ध्यान दें कि && शॉर्ट-सर्किटिंग है, इसलिए तब तक निष्पादित नहीं किया जाता है जब तक कि पहले सत्य मूल्य नहीं मिल जाता है)। रिटर्न (जो कि गलत है) पहली बार चलाया जाता है और फिर हर बार वेतन वृद्धि होती है (और यह सच भी है)। नकारता है, और इसलिए यह truthy पहली बार यह का सामना करना पड़ा और उसके बाद falsey है देता है।$_$_!$x++!$x++$x++0!$x++

Comments

आपके संदेह उचित थे: आपको एक पूर्ण कार्य (या एक पूर्ण कार्यक्रम) प्रस्तुत करने की आवश्यकता है; और यह केवल एक स्निपेट (इसके बिना अमान्य sub{...}) है।

— दादा

Answer 20

पायथ - 9 बाइट्स

.e&b!s<Qk

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

.e&b!s<Qk
.e          # Python's 'enumerate' (i.e., for each index k and each element b at that index)
      <Qk   # The first k elements of the input
     s      # 'Sum' these first k elements (with booleans, this is a logical 'or')
  &b!       # The value of the output at index k is [value of input @ index k]&&[the negation of the 'sum']

Comments

यह एक चर का उपयोग करने के लिए अधिक कुशल प्रतीत होता है और सामान्य रूप से इस पर बस नक्शा m&!~|Z:।

— FryAmTheEggman

Answer 21

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

r=0
while 1:n=input();print n>r;r+=n

इनपुट और आउटपुट एक बूलियन ( ट्रू या गलत ) प्रति पंक्ति है।

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

Answer 22

सी #, 77 बाइट्स

a=>{var b=1<0;for(int i=0;i<a.Length;){a[i]=b?1<0:a[i];b|=a[i++];}return a;};

के संकलन करता है Func<bool[], bool[]>। कुछ भी नहीं वास्तव में चालाक, बस एक सीधे आगे समाधान।

Answer 23

सीड , 16 19 बाइट्स

15 18 बाइट्स सोर्सकोड + 1 बाइट फॉर आर फ्लैग (या बीएसडी सेड के लिए ई फ्लैग)।

:
s/1(0*)1/1\10/
t

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

संपादित करें: एक गलती की ओर इशारा करने के लिए धन्यवाद रिले ।

Comments

@ रिले कि इशारा करने के लिए धन्यवाद! ऐसा लगता है कि TIO में sed का एक संस्करण है जो कि मेरा (BSD) से अलग है। मैं लेबल खाली नहीं छोड़ सकता। यह जानकर अच्छा लगा।

— मैक्सिम मिखायलोव

हाँ क्षमा करें। TIO GNU sed का उपयोग करता है। यह एक बग वाला फीचर है।

— रिले

Answer 24

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

TḊṬ^

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

कैसे?

यह वही है जो एक बहुत शाब्दिक अर्थ में पूछा गया था:

TḊṬ^ - Main link: list a   e.g. [0,1,0,1,0,0,1]  or  [0,1,0,1,0,1,0]
T    - get the truthy indexes   [  2,  4,    7]      [  2,  4,  6  ]
 Ḋ   - dequeue                  [      4,    7]      [      4,  6  ]
  T  - make a boolean array     [0,0,0,1,0,0,1]      [0,0,0,1,0,1  ]
   ^ - XOR that with a          [0,1,0,0,0,0,0]      [0,1,0,0,0,0,0]

Answer 25

सी (जीसीसी बिल्डिंस के साथ), 40

थोड़ा अलग दृष्टिकोण:

f(n){return!n?0:1<<31-__builtin_clz(n);}

इसे अमान्य ठहराया जा सकता है - इस मामले में मैं इसे गैर-प्रतिस्पर्धा के रूप में खुशी से चिह्नित करूंगा।

इनपुट और आउटपुट "सरणियाँ" 32-बिट अहस्ताक्षरित पूर्णांक हैं - यह इनपुट सूची आकार को बिल्कुल 32 तक सीमित करता है - यह एक अयोग्य हो सकता है। यदि इनपुट 32 बिट से कम लंबा है, तो इसे अंत में शून्य बिट्स के साथ गद्देदार किया जा सकता है।

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

Answer 26

बैच, 85 73 बाइट्स

:a
@(if %1.==. exit)&set/ar=(1-f)*%1
@echo %r%&set/af^|=%1&shift&goto a

कमांड लाइन तर्क के रूप में इनपुट लेता है। Eample के लिए:1.bat 0 1 0 1 0 0 1

पुराना वर्जन

@set f=1
:a
@(if %1.==. exit)&set/ar=f*%1
@echo %r%&(if %1==1 set f=)&shift&goto a

Answer 27

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

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

मैं जल्द ही समझाऊंगा लेकिन मेरी माँ ने मुझे कुछ तले हुए आलू पकाए

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<> Subtracts one from every item

({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{} Loops down stack until current item is zero and adds one

(([])<{{} (({})())({<{}>{}((<()>))}<{}{}>) ({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<> On every item of stack if it is 0 do nothing and if it is -1 add one

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

{}{} Remove the two zeros at top of stack

([]){{}({}<>)<>([])}{}<> Flip stack back

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

विशेष धन्यवाद

गेहूं जादूगर और रिले के लिए विशेष धन्यवाद मुझे कोड के साथ एक टन की मदद करने के लिए!

Answer 28

पायथन 3, 69 66 64 60 54 53 बाइट्स

lambda i:[k==i.index(j)and j for k,j in enumerate(i)]

falseएस और trueएस की एक सरणी लेता है । यह एक सूची की समझ है, falseसिवाय इसके कि वर्तमान पुनरावृत्ति का मान है trueऔर यह trueइनपुट में पहला है।

यह थोड़ा लंबा लगता है (और यह मेरा पहला मेमना है), इसलिए यदि आप इसे गोल्फ के लिए एक रास्ता ढूंढ सकते हैं, तो यह बहुत सराहना की जाएगी!

Comments

क्या तुम समझा सकते हो?

— एडम

ओह, उफ़, सवाल का गलत मतलब निकाला।

— OldBunny2800

— पूर्ववत

आप बनाकर एक बाइट बचा सकते हैं 0 for 0for।

— ज़ाचारि

यह 1if और 1else के लिए काम करता है, है ना? धन्यवाद!

— OldBunny2800

Answer 29

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

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

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

# Reverse the stack and add a 1 between each to help with reversing later
([]){{}({}<>)(())<>([])}{}<>

# Add a 1 in case there aren't any truthy values (and another 1 like before)
((()))

# Reverse the stack back to it's original order using the 1s from earlier to know when to stop
{{}({}<>)<>}{}<>

# Push 1 to start the loop
(())

# Until we find the first 1
{

 # Pop the last value
 {}

 # Logical not
 ((){[()](<{}>)}{})

  # Put a 0 on the other stack
  (<>)<>

# end loop
}

# Put a 1 on the other stack
<>(())<>

# Push the stack height
([])

# While there are values on this stack
{

 # Move them to the other stack as a 0
 {}(<{}<>>)<>([])

# End while
}{}

# Pop an extra 0
{}

# Switch stacks
<>

# Copy everything back (to reverse it back to it's original)
([])
{
 {}({}<>)<>([])
}<>{}

Answer 30

पर्ल 5 , 12 बाइट्स

10 बाइट्स कोड + 2 के लिए -pl।

$_&&=!$-++

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