अनुगामी सत्य को गिनें

Question

से प्रेरित होकर, और मेरे प्रिय मित्र और सहयोगी की स्मृति में,

डान बैरोनेट , 1956 - 2016. RIP

उन्होंने इस कार्य के लिए सबसे कम संभव एपीएल समाधान पाया :

कार्य

एक बूलियन सूची को देखते हुए, अनुगामी सत्य मूल्यों की संख्या की गणना करें।

उदाहरण के मामले

{} → 0

{0} → 0

{1} → 1

{0, 1, 1, 0, 0} → 0

{1, 1, 1, 0, 1} → 1

{1, 1, 0, 1, 1} → 2

{0, 0, 1, 1, 1} → 3

{1, 1, 1, 1, 1, 1} → 6

Comments

क्या हम सूची को शून्य और लोगों की एक स्ट्रिंग के रूप में ले सकते हैं? जैसे 01100?

— अदनान

@ अदनान केवल अगर वह बूलियन सूचियों का प्रतिनिधित्व करने के लिए अपनी भाषा के लिए सबसे सामान्य तरीका है।

— Adám

आपको हुई क्षति के लिए क्षमा चाहता हूँ।

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

@MartinEnder धन्यवाद। आगे बढ़ना कठिन होगा। डैन ने मुझे वह सब सिखाया, जो मुझे दिल्लोग के लिए काम करने के लिए जानना जरूरी था।

— Adám

दान को विदाई। RIP ...

— निकोलफर

Answer 1

दिल्लोग एपीएल, 6 2 बाइट्स

⊥⍨

इसे TryAPL पर टेस्ट करें ।

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

⊥ (uptack, dyadic: डिकोड) आधार रूपांतरण प्रदर्शन करती है। यदि बाएं ऑपरेंड एक वेक्टर है, तो यह मिश्रित आधार रूपांतरण करता है , जो इस कार्य के लिए एकदम सही है।

एक बेस वेक्टर के लिए b = b _n , ⋯, b ₀ और एक अंक वेक्टर a = _n , ⋯, ₀ , b mixed , मिश्रित बेस b के लिए एक धर्मान्तरित करता है , अर्थात, यह b _{0 n} b _n-1 a की गणना करता है _n + ⋯ + बी ₀ बी ₁ एक ₂ + b ₀ एक ₁ + एक ₀ ।

अब, comm (tilde dieresis, commute) ऑपरेटर को बाईं ओर निम्नानुसार संशोधित करता है। एक राक्षसी संदर्भ में, यह ऑपरेटर को समान बाएँ और दाएँ तर्क के साथ कहता है।

उदाहरण के लिए, ⊥⍨ एक के रूप में परिभाषित किया गया है एक ⊥ एक जो गणना करता है, एक ₀ ⋯ एक _एन + ⋯ + एक ₀ एक ₁ एक ₂ + एक ₀ एक ₁ + एक ₀ , दाएं से बाएं से सभी संचयी उत्पादों का योग ।

के लिए कश्मीर अनुगामी हैं, कश्मीर दायीं उत्पादों रहे हैं 1 और अन्य सभी कर रहे हैं 0 , इसलिए उनके योग के बराबर है, k ।

Comments

संकेत: दान केवल दो बाइट्स में किया था।

— Adám

मिश्रित आधार रूपांतरण! यह चालाकी है।

— डेनिस

ओह। मिश्रित आधार रूपांतरण, यह फिर से

— कॉनर ओ'ब्रायन

वाहवाही! वास्तव में, दान के कारण, हमने विशेष आवरण b⊥bऔर ⊥⍨bअनंत गति को छोड़ दिया।

— Adám

Answer 2

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

f=l=>l.pop()?f(l)+1:0

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

f=l=>l.pop()?f(l)+1:0

console.log(f([])); // → 0
console.log(f([0])); // → 0
console.log(f([1])); // → 1
console.log(f([0, 1, 1, 0, 0])); // → 0
console.log(f([1, 1, 1, 0, 1])); // → 1
console.log(f([1, 1, 0, 1, 1])); // → 2
console.log(f([0, 0, 1, 1, 1])); // → 3
console.log(f([1, 1, 1, 1, 1, 1])); // → 6

Comments

यह कैसे काम करता है? f(l)+1मान कैसे लौटाता है > 2?

— ओलिवर

@ ओलिवर यह एक पुनरावर्ती प्रक्रिया है, जिसका मूल्यांकन किया गया है l.pop()?(l.pop()?(l.pop()?(...etc...)+1:0)+1:0)+1:0।

— अरनुलद

समझा। स्पष्टीकरण के लिए धन्यवाद।

— ओलिवर

Answer 3

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

ŒrṪP

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

उस मामले के लिए जहां सूची खाली है, कुछ उत्सुक अवलोकन हैं। सबसे पहले, रन-लेंथ खाली सूची एन्कोडिंग एक और खाली सूची []देता है []। फिर एक जोड़ी के बजाय पूंछ Ṫरिटर्न का उपयोग करके अंतिम तत्व को पुनः प्राप्त करना जो एक रन-लंबाई एन्कोडेड सरणी के नियमित तत्व हैं। तब उत्पाद लौटाया जाता है जिस पर अपेक्षित परिणाम होता है।0[value, count]P00

व्याख्या

ŒrṪP  Main link. Input: list M
Œr    Run-length encode
  Ṫ   Tail, get the last value
   P  Product, multiply the values together

Comments

वैकल्पिक रूप से, ŒgṪSकाम करता है, भी!

— लिन

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

— पीटर टेलर

@PeterTaylor मुझे भी आश्चर्य है कि यह काम किया। इसके अलावा, मैंने अभी देखा कि पहले लिंक में गलत कोड है।

— मील

@PeterTaylor Ṫजेली में के रूप में कार्यान्वित किया जाता है: lambda z: iterable(z).pop() if iterable(z) else 0। iterableजब किसी सूची पर कॉल किया जाता है तो वह सूची वापस कर देता है, और खाली सूची निश्चित रूप से मिथ्या होती है।

— FryAmTheEggman

Answer 4

ब्रेकीलॉग , 7 6 5 बाइट्स

@]#=+

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

व्याख्या

@]        A suffix of the Input...
  #=      ...whose elements are all equal
    +     Sum its elements

चूँकि @] - Suffixसबसे बड़े प्रत्यय से शुरू होकर छोटे से छोटे तक, यह सबसे पहले चलने वाला सबसे बड़ा भाग होगा।

Answer 5

CJam (8 बाइट्स)

{W%0+0#}

ऑनलाइन टेस्ट सूट

विच्छेदन

{    e# begin a block
  W%  e# reverse the array
  0+  e# append 0 so there's something to find
  0#  e# find index of first 0, which is number of nonzeros before it
}

Answer 6

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

a%b|b=1+a|0<3=0
foldl(%)0

उपयोग:

Prelude> foldl(%)0 [True,False,True,True]
2

पॉइंटफ्री संस्करण (26 बाइट्स):

length.fst.span id.reverse

---

बूल सूची के बजाय पूर्णांक सूची का उपयोग करना (21 बाइट्स, क्रिश्चियन सेवर्स के लिए धन्यवाद):

a%b=b*(a+1)
foldl(%)0

उपयोग:

Prelude> foldl(%)0 [1,0,1,1]
2

पॉइंटफ्री संस्करण (25 बाइट्स)

sum.fst.span(==1).reverse

Comments

पूर्णांक सूचियों के foldlसाथ विचार काम करता हैa%b=b*(a+1)

— क्रिश्चियन सेवर्स 16

Answer 7

रेटिना , 7 5 बाइट्स

r`1\G

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

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

एकल-चरित्र अभ्यावेदन के साथ, हमें सूची के लिए एक विभाजक की आवश्यकता नहीं है (जो एक तरह से, किसी भाषा के लिए अधिक प्राकृतिक सूची प्रतिनिधित्व है जिसमें केवल तार हैं)। Adám ने पुष्टि की कि यह एक स्वीकार्य इनपुट प्रारूप है।

रेगेक्स ही के लिए, यह right से बाईं ओर मेल खाता है और \Gप्रत्येक मैच को पिछले एक से जोड़ता है । इसलिए, यह मायने रखता है कि 1हम कितने एस स्ट्रिंग के अंत से मेल कर सकते हैं।

Comments

"हाँ, रेटिना के लिए, कि यह केवल तार संभालती है, मुझे लगता है कि एक" 01 "या" एफटी "स्ट्रिंग क्रम में है।

— Adám

Answer 8

05AB1E , 12 10 6 5 बाइट्स

Carusocomputing के लिए 1 बाइट का धन्यवाद सहेजा गया ।

Î0¡¤g

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

व्याख्या

Î      # push 0 and input
 0¡    # split on 0
   ¤   # take last item in list
    g  # get length

Comments

0¡¤gचार बाइट्स है।

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

@carusocomputing: अच्छा! यह स्पष्ट नहीं किया गया था कि क्या स्ट्रिंग इनपुट ठीक था जब मैंने यह लिखा था, लेकिन मैं अब देख रहा हूं कि यह :) है

— एमिगा

J0¡¤gअभी भी छोटा है;)

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

@carusocomputing: दुर्भाग्य से हमें Îखाली इनपुट को संभालने की आवश्यकता है, लेकिन यह अभी भी एक बाइट है धन्यवाद धन्यवाद :)

— Emigna

Answer 9

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

lambda a:(a[::-1]+[0]).index(0)

Answer 10

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

ṣ0ṪL

TryItOnline! , या सभी परीक्षण

कैसे?

ṣ0ṪL - Main link: booleanList
ṣ0   - split on occurrences of 0 ([] -> [[]]; [0] -> [[],[]]; [1] -> [[1]]; ...)
  Ṫ  - tail (rightmost entry)
   L - length

Answer 11

MATL , 4 बाइट्स

PYps

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

P       % Flip
 Yp     % Cumulative product
   s    % Sum

Answer 12

गणितज्ञ, २५ २४ बाइट्स

Fold[If[#2,#+1,0]&,0,#]&

Comments

डैन के शांत मिश्रित-बेस समाधान के एक पोर्ट को रिकॉर्ड करना: FromDigits[b=Boole@#,MixedRadix@b]&(35 बाइट्स)।

— ग्रेग मार्टिन

Answer 13

अजगर, 6 बाइट्स

x_+0Q0

यहाँ कोशिश करो!

एक 0 को लागू करता है, उलटा करता है और पहले 0 का सूचकांक पाता है

Comments

@ जकुबे ने अब तय किया - अलग एल्गोरिथ्म

— ब्लू

Answer 14

C90 (gcc), 46 बाइट्स

r;main(c,v)int**v;{while(0<--c&*v[c])r++;c=r;}

इनपुट कमांड-लाइन तर्कों (एक पूर्णांक प्रति तर्क) के माध्यम से होता है, आउटपुट आउट कोड के माध्यम से होता है ।

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

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

r एक वैश्विक चर है। इसका प्रकार int के लिए डिफ़ॉल्ट है और, वैश्विक होने के कारण, यह मान को 0 से चूकता है ।

फ़ंक्शन तर्क c डिफ़ॉल्ट के साथ-साथ int । यह एन बूलियन्स की सरणियों के लिए पूर्णांक एन + 1 धारण करेगा ; मुख्य का पहला तर्क हमेशा निष्पादन योग्य का मार्ग है।

फ़ंक्शन तर्क v के रूप में घोषित किया गया है int**। के वास्तविक प्रकार वी हो जाएगा char**, लेकिन जब से हम केवल प्रत्येक तर्क के कम से कम महत्वपूर्ण बिट वर्ण बताने के लिए जांच करेंगे 0 (कोड बिंदु 48 ) और 1 (कोड बिंदु 49 ) के अलावा, इस पर थोड़ा-endian कोई फर्क नहीं होगा मशीनों।

जबकि लूप घटता है c और इसकी तुलना 0 से करता है । एक बार c 0 तक पहुंचने के बाद , हम लूप से बाहर निकल जाएंगे। यह केवल तभी आवश्यक है जब सरणी में कोई 0 नहीं है ।

जब तक 0<--cरिटर्न 1 होता है , हम c ^वें कमांड-लाइन तर्क ( v[c]) लेते हैं और इसके पहले अक्षर को पॉइंटर (dereferencing) करके निकालते हैं *। हम बिटवाइज़ और बूलियन के ले 0<--c, और चरित्र (और तीन कचरा बाइट्स है कि यह पालन) का कोड बिंदु तो हालत वापस आ जाएगी 0 बार एक 0 का सामना करना पड़ा है, लूप के बाहर तोड़ दिया।

शेष मामले में, जबकि कमांड लाइन तर्क हैं 1 , r++वृद्धि कर देता है आर द्वारा 1 , इस प्रकार अनुगामी की संख्या की गणना 1 के।

अंत में, सी में आरc=r के गणना मूल्य को संग्रहीत करता है । डिफ़ॉल्ट सेटिंग्स के साथ, कंपाइलर असाइनमेंट को ऑप्टिमाइज़ और हटा देता है; यह वास्तव में निर्देश उत्पन्न करता है । चूंकि EAX रजिस्टर का मूल्य लौटाता है, यह वांछित आउटपुट उत्पन्न करता है।movl %eax, -4(%rbp)ret

ध्यान दें कि यह कोड C99 के साथ काम नहीं करता है , जो कि मुख्य के अंत तक पहुंचने पर मुख्य से 0 वापस आता है।

Comments

Isn't argcकम से कम 1(के साथ argv[0]फ़ाइल नाम युक्त)? आप के --c&&बजाय के साथ एक बाइट बचा सकता है 0<--c&। gcc का निकास कोड किससे लिया जाता है argc? साफ।

— टाइटस

@ टिट्स जो काम नहीं करेगा। 1 या 0*v[c] का कोड बिंदु है , इसलिए यह 49 या 48 है और इस प्रकार हमेशा सत्य है।

— डेनिस

C89 और C90 के साथ, उस समय RAX में जो कुछ भी है, gcc रिटर्न देता है। C99 हमेशा मुख्य से 0 रिटर्न करता है अगर अंत तक पहुँच जाता है।

— डेनिस

Answer 15

k, 6 बाइट्स

+/&\|:

यह समारोह रचना sum mins reverseमें q, भाषा की अधिक पठनीय सहोदर में अनुवाद करता है , जहाँ न्यूनतम रोल न्यूनतम होता है।

Comments

क्या: गिराया जा सकता है?

— स्ट्रीटस्टर

Answer 16

जे, ९ ३ बाइट्स

#.~

यह रिफ्लेक्टिव मिश्रित आधार रूपांतरण है। क्योंकि यह मिश्रित आधार रूपांतरण के समान है। फिर।

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

   v =: #.~
   ]t =: '';0;1;0 1 1 0 0;1 1 1 0 1;1 1 0 1 1;0 0 1 1 1;1 1 1 1 1 1
++-+-+---------+---------+---------+---------+-----------+
||0|1|0 1 1 0 0|1 1 1 0 1|1 1 0 1 1|0 0 1 1 1|1 1 1 1 1 1|
++-+-+---------+---------+---------+---------+-----------+
   v&.> t
+-+-+-+-+-+-+-+-+
|0|0|1|0|1|2|3|6|
+-+-+-+-+-+-+-+-+
   (,. v&.>) t
+-----------+-+
|           |0|
+-----------+-+
|0          |0|
+-----------+-+
|1          |1|
+-----------+-+
|0 1 1 0 0  |0|
+-----------+-+
|1 1 1 0 1  |1|
+-----------+-+
|1 1 0 1 1  |2|
+-----------+-+
|0 0 1 1 1  |3|
+-----------+-+
|1 1 1 1 1 1|6|
+-----------+-+

Comments

संकेत: डैन के समाधान के जे अनुवाद का उपयोग करके यह केवल 3 बाइट्स में किया जा सकता है।

— Adám

@ Adám मैंने एक समाधान खोजने की कोशिश की। आधार रूपांतरण के बारे में नहीं सोचा था। वह वास्तव में काफी चालाक है!

— कॉनर ओ'ब्रायन

हाँ। वह दान था। :-(

— Adám

Answer 17

आर, 40 39 25 बाइट्स

पूरी तरह से reworked समाधान के लिए धन्यवाद @Dason

sum(cumprod(rev(scan())))

स्टड से इनपुट पढ़ें, वेक्टर को उल्टा करें और यदि का पहला तत्व है !=0तो रन-लेंथ एन्कोडिंग ( rle) की पहली लंबाई का उत्पादन करें , अन्यथा 0।

Comments

आप दूसरी पंक्ति को बदलकर एक बाइट बचा सकते हैं ifelse(r$v,r$l,0)[1]। (अगर, और फिर पहला तत्व लिया जाए तो)।

— rturnbull

Iflelse के लिए कोई ज़रूरत नहीं है - बस आर $ वी और आर $ एल को गुणा करें।

— दासोन

लेकिन राशि (cumprod (Rev।))) मार्ग को बहुत से बाइट्स को बचाना चाहिए

— Dason

Answer 18

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

foldl(\a b->sum[a+1|b])0

सूची में Iterates, प्रत्येक तत्व के लिए एक जोड़ने के 0बाद इसे हिट करने के लिए रीसेट करना False।

0/1 इनपुट के साथ 16 बाइट्स :

foldl((*).(+1))0

यदि सूची गैर-रिक्त की गारंटी थी, तो हम 14 बाइट्स प्राप्त कर सकते हैं:

sum.scanr1(*)1

यह पीछे से संचयी उत्पाद की गणना करता है, फिर उन्हें रकम देता है। संचयी उत्पाद 1 रहता है जब तक 0 हिट नहीं होता है, और फिर 0. हो जाता है, तो 1 के अनुगामी 1 के अनुरूप होता है।

Answer 19

Pyke, 10 6 बाइट्स

_0+0R@

यहाँ कोशिश करो!

Answer 20

सी # 6, 103 72 बाइट्स

using System.Linq;
int a(bool[] l)=>l.Reverse().TakeWhile(x=>x).Count();

गैर-जेनेरिक सूची का उपयोग करना 1 बाइट लोल द्वारा जेनेरिक सूची धड़कता है

-31 बाइट्स स्कॉट के लिए धन्यवाद

Comments

आप की एक सरणी का उपयोग करते हैं intरों, आप के साथ प्राप्त कर सकते हैंint a(int[] l)=>l.Reverse().TakeWhile(i=>i>0).Sum();

— स्कॉट

@ बेशक मैं क्या सोच रहा था ... मैं हालांकि बूल के साथ रहूंगा। प्रश्न बूलियन सूची को निर्दिष्ट करता है और यह C. नहीं है

— लिंक Ng

Func<bool[], int>57 बाइट्स के लिए संकलित करेंusing System.Linq;l=>l.Reverse().TakeWhile(x=>x).Count();

— TheLethalCoder

Answer 21

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

f=lambda l:len(l)and-~f(l[:-1])*l[-1]

Answer 22

डीएएसएच , 16 बाइट्स

@len mstr"1+$"#0

यह सबसे कम संभव DASH समाधान नहीं है, लेकिन सबसे कम संभव DASH समाधान मेरे लिए खराब कर रहा है। मैं इस उपन्यास दृष्टिकोण को इसके स्थान पर पोस्ट कर रहा हूं।

उपयोग:

(@len mstr"1+$"#0)"100111"

व्याख्या

@(                 #. Lambda
  len (            #. Get the length of the array after...
    mstr "1+$" #0  #. ... matching the argument with regex /1+$/
  )                #. * mstr returns an empty array for no matches
)

Answer 23

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

l=>l.reverse:+0 indexOf 0

Ungolfed:

l=>(l.reverse :+ 0).indexOf(0)

सूची को उलटता है, एक 0 को जोड़ता है और 0 का पहला सूचकांक ढूंढता है, जो कि पहले 0 से पहले तत्वों की संख्या है

Answer 24

बैच, 57 बाइट्स

@set n=0
@for %%n in (%*)do @set/an=n*%%n+%%n
@echo %n%

कमांड-लाइन मापदंडों के रूप में इनपुट लेता है। संचयकर्ता को चालू करने से पहले संचयकर्ता को गुणा करके काम करता है, ताकि कमांड लाइन में कोई भी शून्य गणना को रीसेट कर दे। ध्यान दें कि चर या चर %%nके समान नहीं है ।n%n%

Answer 25

गोल्फशर्प, 14 बाइट्स

n=>n.V().O(F);

Answer 26

जावा 7, 62 बाइट्स

int c(boolean[]a){int r=0;for(boolean b:a)r=b?r+1:0;return r;}

Ungolfed और परीक्षण कोड:

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

class M{
  static int c(boolean[] a){
    int r = 0;
    for (boolean b : a){
      r = b ? r+1 : 0;
    }
    return r;
  }

  public static void main(String[] a){
    System.out.print(c(new boolean[]{}) + ", ");
    System.out.print(c(new boolean[]{ false }) + ", ");
    System.out.print(c(new boolean[]{ true }) + ", ");
    System.out.print(c(new boolean[]{ false, true, true, false, false }) + ", ");
    System.out.print(c(new boolean[]{ true, true, true, false, true }) + ", ");
    System.out.print(c(new boolean[]{ true, true, false, true, true }) + ", ");
    System.out.print(c(new boolean[]{ false, false, true, true, true }) + ", ");
    System.out.print(c(new boolean[]{ true, true, true, true, true, true }));
  }
}

आउटपुट:

0, 0, 1, 0, 1, 2, 3, 6

Answer 27

पर्ल 5.10, 22 बाइट्स

-aझंडे के लिए 21 बाइट्स + 1 बाइट । चूंकि रेगेक्स-आधारित अभिव्यक्ति की गई थी ...: पी

सरणी के लिए इनपुट मान को एक स्थान से अलग किया जाना चाहिए।

$n++while pop@F;say$n

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

Comments

यदि आप कमांड लाइन के माध्यम से तर्क लेते हैं, तो थोड़ा कम: perl -E '$_++while pop;say' 0 1 1 0 1 1 1लेकिन यह कुछ भी आउटपुट नहीं करता है 0(यदि यह समस्या है तो निश्चित नहीं है!)

— डोम हेस्टिंग्स

Answer 28

पर्ल, 22 बाइट्स

-pध्वज के लिए कोड + 1 बाइट के 21 बाइट्स ।

s/.(?=.*0)//g;$_=y;1;

इसे चलाने के लिए:

perl -pE 's/.(?=.*0)//g;$_=y;1;' <<< "0 1 1 0 1 1 1"

(वास्तव में, इनपुट का स्वरूप एक बहुत फर्क नहीं पड़ता: 0110111, 0 1 1 0 1 1 1, [0,1,1,0,1,1,1]आदि होगा सब काम)

---

@Dom हेस्टिंग्स से 18 बाइट्स संस्करण , लेकिन इसे 0 और 1 के स्ट्रिंग के रूप में इनपुट की आपूर्ति करने की आवश्यकता है, जिसकी अनुमति नहीं है:

perl -pE '/1*$/;$_=length$&' <<< '0110111'

Comments

उस ;चाल को प्यार करना :) अगर प्रारूप एक निरंतर स्ट्रिंग है: perl -pE '/1*$/;$_=length$&' <<< '0110111'18 के लिए, निश्चित नहीं है कि क्या वह नियमों को झुका रहा है या नहीं ...

— डोम हेस्टिंग्स

@DomHastings हाँ, मुझे भी! (मुझे दिखाने के लिए धन्यवाद टन!) सवाल थोड़े की पहली और दूसरी टिप्पणी इनपुट के प्रारूप को बाधित करती है जिसे आपको अपने समाधान की आवश्यकता है ... लेकिन अगर इनपुट का प्रारूप अधिक था, तो मैं आपके पोस्ट को संपादित करने के लिए अपनी पोस्ट संपादित करूंगा नि: शुल्क।

— दादा

Answer 29

PHP, 50 बाइट्स

<?=strlen(preg_filter('/.*[^1]/','',join($argv)));

अजीब तरह से मेरी पहली कोशिश एक रेक्सक्स के साथ हुई जो मेरी कोशिशों के मुकाबले कम है ...
उपयोग की तरह:

php tt.php 1 1 0 1 1

Answer 30

रूबी 37 32 बाइट्स

->n{n.size-1-(n.rindex(!0)||-1)}

एक अनाम फ़ंक्शन बनाता है जो एक गलत मान का सही-सबसे अधिक उदाहरण पाता है, और उस मूल्य पर शुरू होने वाले सबर्रे के आकार को गिनता है।

यह !0गलत के रूप में उपयोग करता है , क्योंकि 0 रूबी में सत्य मान हैं। rindexकिसी सरणी में मान का अंतिम सूचकांक पाता है।

उपयोग :

boolean_list = [true, false, false, true]
->n{n.size-1-(n.rindex(!0)||-1)}[boolean_list]

लौटता है १

---

अगर मुझे कमांड लाइन मापदंडों के रूप में 0s और 1s की एक स्ट्रिंग पारित करने की अनुमति दी गई थी (जो रूबी बूलियंस की सूची का प्रतिनिधित्व नहीं करता है), तो मैं इसे 24 तक नीचे ला सकता हूं:

$*[0]=~/(1*)\z/;p$1.size

यह नियमित अभिव्यक्ति का उपयोग करता है और नियमित अभिव्यक्ति द्वारा लौटे स्ट्रिंग की लंबाई को प्रिंट करता है /(1*)\z/, जहां \zस्ट्रिंग का अंत है। $*[0]पास किया गया पहला तर्क है और 0 और 1 s का स्ट्रिंग है।

उपयोग:

trailing_truths.rb 011101

लौटता है १।

Comments

एक बार जब आपके पास अंतिम गलत मूल्य का सूचकांक होता है, तो आपको फिर से सरणी से तत्वों को पुनः प्राप्त करने की आवश्यकता क्यों है?

— ली डब्ल्यू

तुम सही हो, मैं नहीं। धन्यवाद। 5 बाइट्स!

— IMP1