35

जब मैं एक बच्चा था, और अपने जीवन की बचत में डॉलर के बिलों को गिनना चाहता था, तो मैं ज़ोर से गिनूंगा:

एक दो तीन चार पांच छ सात आठ नौ दस;
ग्यारह, बारह, तेरह, चौदह, पंद्रह, सोलह, सत्रह, अठारह, उन्नीस, बीस;
इक्कीस, बाईस, तेईस, चौबीस, पच्चीस ...

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

एक दो तीन चार पांच छ सात आठ नौ दस;
एक, दो, तीन, चार, पांच, छह, सात, आठ, नौ, बीस;
एक, दो, तीन, चार, पांच, छह, सात, आठ, नौ, तीस ...

जैसा कि आप देख सकते हैं, मैं केवल अंकों (अंकों) का उच्चारण करूंगा जो पिछले संख्या से बदल गए हैं। इसका अतिरिक्त लाभ यह है कि यह संख्याओं के लिए अंग्रेजी नामों की तुलना में काफी अधिक दोहरावदार है, और इसलिए गणना करने के लिए कम मस्तिष्क शक्ति की आवश्यकता होती है।

चुनौती

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

उदाहरण

परीक्षण-मामलों की पूरी सूची आवश्यक नहीं होनी चाहिए। यह OEIS पर A274206 है।

नियम

आपका प्रवेश सभी सकारात्मक पूर्णांकों के लिए सैद्धांतिक रूप से काम करना चाहिए, सटीक और स्मृति मुद्दों की अनदेखी करना।
इनपुट और आउटपुट दशमलव में होना चाहिए।
आप संख्या, स्ट्रिंग या अंकों की एक सरणी के रूप में इनपुट और / या आउटपुट लेना चुन सकते हैं।
इनपुट एक सकारात्मक पूर्णांक होने की गारंटी है। आपकी प्रविष्टि अमान्य इनपुट के लिए कुछ भी कर सकती है।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

code-golf number

— ETHproductions
स्रोत

तो क्या "दशमलव में" दशमलव अंकों की एक सूची शामिल करता है, जैसे [1,0,2,0]-> [2,0]अंतिम परीक्षण मामले के लिए? (मैं "एकल-आइटम सरणी" वाक्यांश पर अस्पष्ट हूं)।

— जोनाथन एलन

1

@JonathanAllan "सिंगल-आइटम ऐरे" से मेरा मतलब एक ऐसे एरर से है जिसमें सिंगल नंबर या स्ट्रिंग होता है जो पूर्णांक का प्रतिनिधित्व करता है। मुझे नहीं लगा कि अंकों के सरणियों को अनुमति देना एक अच्छा विचार था, लेकिन अब यह एक तरह से मनमाना प्रतिबंध लगता है क्योंकि तार की अनुमति है (और तार कई भाषाओं में सरणियों के समान हैं)। जब तक कोई अच्छा कारण न हो, तब तक मैं अंकों की एक सरणी की अनुमति दूंगा।

— ETHproductions

5

इसे डांग, आपने मेरा रहस्य चुरा लिया: पी

— लीजनमैमल 978

1

मुझे लगता है कि लगभग सभी ने इस तरह से एक बच्चे के रूप में गिना। ;) कम से कम मैंने भी किया। :)

— केविन क्रूज़सेन

7

@KevinCruijssen "एक बच्चे के रूप में"?

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

19

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

f=lambda n:n%10or 10*f(n/10)

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

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

— XNOR
स्रोत

11

जेली , 6 3 बाइट्स

-3 बाइट्स अंकों की एक दशमलव सूची के रूप में I / O होने से ।

ṫTṪ

टेस्ट सूट ऑनलाइन यह कोशिश करो!

कैसे?

ṫTṪ - Main link: listOfDigits  e.g.  [1,    0,    2,    0]  or [1,      1,    9  ]
 T  - truthy indexes                 [1,          3      ]     [1,      2,    3  ]
ṫ   - tail (vectorises)              [[1,0,2,0],  [2,0]  ]     [[1,1,9],[1,9],[9]]
  Ṫ - tail pop                                    [2,0]                       [9]

अगर हम दशमलव सूची को नहीं ले सकते हैं तो 6 बटर है:

DµṫTṪḌ

जिसे आप यहां देख सकते हैं ।

यह वही काम करता है, लेकिन एक पूर्णांक को दशमलव सूची में पहले से परिवर्तित करता है और बाद में पूर्णांक में परिवर्तित करता है।

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

जैसा कि मैं पहले कुछ उत्तरों को

— आगे बढ़ा

9

सी, 30 29 27 बाइट्स

इस बात पर गर्व है कि मैं दो सी का दुरुपयोग करता हूं, इस बात का खुलासा करने के लिए (पोस्ट के अंत में वर्णित); यह विशेष रूप से C (GCC) के लिए है

3) b=10;f(a){a=a%b?:b*f(a/b);}// 27 बाइट्स

2) ~~b;f(a){b=a=a%10?:10*f(a/10);}~~// 29 बाइट्स

1) ~~f(i){return i%10?:10*f(i/10);}~~// 30 बाइट्स

इसे ऑनलाइन आज़माएँ (27 बाइट संस्करण)

पहला प्रयास (30 बाइट्स): इस तथ्य का दुरुपयोग करता है कि जीसीसी में अगर कोई मूल्य टर्नरी में घोषित नहीं किया गया है, तो सशर्त मूल्य वापस आ जाएगा। इसलिए सत्य वापसी मूल्य के लिए मेरा टर्नरी ऑपरेटर क्यों खाली है।

दूसरा प्रयास (29 बाइट्स): जीसीसी में मेमोरी बग का दुरुपयोग , जहां तक मैं समझता हूं, यदि किसी फ़ंक्शन का कोई रिटर्न मान नहीं है, जब फ़ंक्शन में दो से अधिक चर का सार्थक उपयोग किया गया है, तो पहले तर्क चर का अंतिम सेट मान लौटा दी जाएगी।
(संपादित करें: लेकिन इस "सेट वैल्यू" को कुछ तरीकों से सेट किया जाना चाहिए, उदाहरण के लिए एक चर के साथ =या +=कार्यों को सेट करना, लेकिन इसे सेट करना आसान %=नहीं है;)

तीसरा प्रयास (27 बाइट्स): चूँकि मैं सार्थक रूप से ऊपर बताए गए मेमोरी बग का ठीक से दुरुपयोग करने के लिए दूसरे चर (बी) का उपयोग कर सकता हूं, इसलिए मैं प्रतिस्थापन के लिए "10" के लिए वास्तविक चर के रूप में भी इसका उपयोग कर सकता हूं।
(नोट: मैं स्वैप में सक्षम होना चाहिए a=a%bके साथ a%=bएक और बाइट को बचाने के लिए लेकिन दुर्भाग्य से इस का कारण बनता है स्मृति बग "काम" को रोकने के लिए इसके बाद के संस्करण का फायदा उठाने, तो मैं नहीं कर सकता)

— अल्बर्ट रेनशॉ
स्रोत

आप अपने उत्तर के शीर्षक में "जीसीसी" जोड़ना चाह सकते हैं क्योंकि यह जीसीसी-विशिष्ट है (यह क्लैंग पर काम नहीं करता है)। इसके अलावा, "मेमोरी बग" शायद सिर्फ अपरिभाषित व्यवहार है जो कि जीसीसी द्वारा उपयोग किए जाने वाले विशिष्ट स्टैक फ्रेम लेआउट के कारण काम करने के लिए होता है। यह शायद अन्य प्लेटफार्मों पर काम नहीं करता है, यहां तक कि जीसीसी के साथ भी।

— सिमोन

@ गुरू दून, धन्यवाद

— अल्बर्ट

7

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

!`.0*$

इसे ऑनलाइन आज़माएं (सभी परीक्षण मामले)

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

— mbomb007
स्रोत

हुह, मुझे लगा था [1-9](या [^0]) इसके बजाय आवश्यक होगा \d। मैं *हर बार सही आउटपुट सुनिश्चित करने के लालच का अनुमान लगाता हूं ।

— ETHproductions

@ETHproductions इसका कोई लालच नहीं है, *लेकिन इस तथ्य के साथ कि मैचों को बाएं से दाएं खोजा जाता है। \d0*?$काम भी करेगा।

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

रेगेक्स का उपयोग .0*$करना चाहिए

— 12Me21

यदि केवल अंतिम मैच के उत्पादन के लिए एक छोटा (पर्याप्त) तरीका है, तो आप उपयोग कर सकते हैं.0*

— 12M2121

@ 12Me21 ऐसा करने का एकमात्र तरीका केवल अंतिम घटना से मेल खाता है, या एक प्रतिस्थापन या कुछ का उपयोग करना है। यह छोटा नहीं होगा।

— mbomb007

7

क्यूबिक्स , 18 32 बाइट्स

मुझे लगता है कि मुझे इस पर बाद में कुछ समय बिताना होगा और देखना होगा कि क्या मैं इसे थोड़ा संकुचित कर सकता हूं। लेकिन फिलहाल यहां है।
पता चला कि मैं इस बारे में पूरी तरह से गलत सोच रहा था। अब यह इन्क्रिमेंटली इनपुट पूर्णांक पर एक मॉड (1,10,100,1000, ...) लागू करता है और पहले वाले को प्रिंट करता है जो शून्य नहीं है। थोड़ा और उबाऊ, लेकिन कम।

!N%*I1^\.u;u@O\;;r

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

    ! N
    % *
I 1 ^ \ . u ; u
@ O \ ; ; r . .
    . .
    . .

— MickyT
स्रोत

एक क्यूबिक्स उत्तर देखने के लिए हमेशा अच्छा है :)

— ओलिवर

@obarakon जल्द ही सुधार लाने के लिए एक बेहतर समझे। वास्तव में यह एक गलत तरीका था

— मिकी

5

जावास्क्रिप्ट, 21 बाइट्स

f=n=>n%10||10*f(n/10)

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

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

f=n=>n%10||10*f(n/10)

console.log(f(1   )); //  1
console.log(f(2   )); //  2
console.log(f(10  )); //  10
console.log(f(29  )); //  9
console.log(f(99  )); //  9
console.log(f(1020)); //  20

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

— ओलिवर
स्रोत

5

जावास्क्रिप्ट 19 18 बाइट्स

एक बाइट को बंद करने के लिए ETHproductions और दो बाइट को बंद करने के लिए पैट्रिक रॉबर्ट्स को धन्यवाद

x=>x.match`.0*$`

स्ट्रिंग की एक सरणी देता है जो इनपुट स्ट्रिंग के अंत में किसी भी वर्ण के साथ सबसे बड़ी संख्या में शून्य के बाद होने के कारण से मेल खाता है।

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

— fənɛtɪk
स्रोत

5

मुझे नहीं लगता कि आपको इसकी आवश्यकता है g, क्योंकि खोजने के लिए केवल एक ही मैच है।

— ETHproductions

का उपयोग करके 2 बाइट्स सहेजेंx=>x.match`.0*$`

— पैट्रिक रॉबर्ट्स

3

बैश + कोरुटिल्स, 12

grep -o .0*$

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

— डिजिटल आघात
स्रोत

3

पीस , 5 बाइट्स

d\0*e

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

व्याख्या

       Find the longest substring of the input matching this pattern:
d      a digit, then
 \0*   zero or more 0s, then
    e  edge of input (which is handled as an Nx1 rectangle of characters).

— Zgarb
स्रोत

3

ब्रेकीलॉग , 2 बाइट्स

a₁

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

a₁पूर्णांक के लिए निर्मित प्रत्यय , इस प्रकार लागू किया जाता है:

brachylog_adfix('integer':1, 'integer':0, 'integer':0).
brachylog_adfix('integer':1, 'integer':I, 'integer':P) :-
    H #\= 0,
    H2 #\= 0,
    abs(P) #=< abs(I),
    integer_value('integer':Sign:[H|T], I),
    integer_value('integer':Sign:[H2|T2], P),
    brachylog_adfix('integer':1, [H|T], [H2|T2]).

ब्रेकीलॉग पूर्णांक को अंकों की सूची के रूप में व्यवहार करना पसंद करता है, और इसके लिए यह कस्टम उपयोगिता का उपयोग करता है integer_value/2। integer_value/2यहाँ के बारे में दिलचस्प बात यह है कि चूँकि इसे प्रमुख शून्य के साथ अंक सूची को सही ढंग से अनुवाद करने में सक्षम होना पड़ता है, इसलिए यह समाप्त हो जाता है ताकि अग्रणी शून्य के साथ अंक सूची में पूर्णांक का अनुवाद किया जा सके, इसलिए यह भविष्यवाणी करता है कि ऐसा नहीं करना चाहिए ऐसा होता है (उनमें से अधिकांश, विशेष रूप से नोंडेट्स जैसे a) अपने अंकों की सूचियों के प्रमुखों को 0. से मना करते हैं। इसलिए, जबकि a₁सूचियों और तारों के लिए सबसे पहले प्रत्यय उत्पन्न होता है, यह एक अग्रणी 0 के साथ पूर्णांक के किसी भी प्रत्यय को छोड़ देता है, जिसमें डुप्लिकेट को हटाने के अलावा, यह भी मतलब है कि उत्पन्न पहला प्रत्यय सभी अनुगामी शून्य के साथ सबसे सही गैर-शून्य अंक है।

— असंबंधित स्ट्रिंग
स्रोत

2

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

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

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

केवल अंतिम गैर 0 को प्रिंट करता है और सभी 0 को पीछे छोड़ता है।

स्पष्टीकरण:

{({}<>)<>}                    # Move everything to the other stack (reverse the input)
(())                          # Push a 1 to get started
{                             # do...
  {}<>                        #   pop the result of the equals check (or initial 1)
  (                           #   push...
    ({}<>)                    #     the top value from the other stack (also put this on the stack)
    [((((()()()){}){}){}){}]  #     minus the ASCII value of 0
    <(())>                    #     on top of a 1
  )                           #   close the push   
  {                           #   if not zero (ie. if not equal)
    ((<{}{}>))                #     replace the 1 from 3 lines back with a 0
  }{}                         #   end if and pop the extra 0
}                             # while the copied value != "0"
{}                            # pop the result of the equals check

— रिले
स्रोत

2

विम, 19 बाइट्स

दो संस्करण, दोनों 19 बाइट्स:

:s/\v.*([^0]0*)/\1
:s/.*\([^0]0*\)/\1

इसके अलावा प्रत्येक पर एक पीछे चलने वाली गाड़ी वापस आती है।

सभी परीक्षण-मामलों को ऑनलाइन सत्यापित करें! (एक बाइट कई लाइनों पर परीक्षण करने के लिए जोड़ा गया)

— DJMcMayhem
स्रोत

2

टीआई-बेसिक, 18 बाइट्स

If fPart(.1Ans
Return
Ans.1
prgmA
10Ans

— Timtech
स्रोत

2

आर, 33 बाइट्स

एक अनाम फ़ंक्शन के रूप में कार्यान्वित किया गया

function(x)rle(x%%10^(0:99))$v[2]

यह 10 ^ 99 के माध्यम से 10 ^ 0 का एक मॉड लागू करता है। rleपरिणाम को कम करने के लिए उपयोग किया जाता है ताकि दूसरा आइटम हमेशा वह परिणाम हो जो हम चाहते हैं।
इसे ऑनलाइन आज़माएं!

— MickyT
स्रोत

2

Zsh , 18 16 बाइट्स

<<<${(M)1%[^0]*}

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

बैश , 25 बाइट्स

r=${1%[^0]*}
echo ${1#$r}

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

शेल को रेगेक्स का उपयोग करने के लिए बाहरी कार्यक्रमों को कॉल करने की आवश्यकता होती है, इसलिए हमें ग्लोबिंग के साथ करना होगा।

${1%[^0]*}विस्तार कम से कम प्रत्यय एक अशून्य चरित्र के साथ शुरुआत से मेल खाता है, और यह निकाल देता है।

Zsh में, (M)ध्वज जोड़ने से हटाए गए के बजाय मिलान किए गए प्रत्यय को रखा जाता है।
बैश में, ${1% }जो कुछ भी बचा है, उपसर्ग के रूप में विस्तार हटा देता है।

— GammaFunction
स्रोत

1

GNU सेड , 17 14 + 1 (आर झंडा) = 15 बाइट्स

संपादित करें: 2 बाइट्स रिले के लिए कम धन्यवाद

s:.*([^0]):\1:

यह सही-सबसे नॉनजेरो अंक तक सब कुछ हटाकर काम करता है, जो तब किसी भी मौजूदा ट्रेलिंग शून्य के साथ मुद्रित होता है। स्क्रिप्ट एक रन में कई परीक्षणों को संभाल सकती है, प्रत्येक एक अलग लाइन पर।

इसे ऑनलाइन आज़माएं! (सभी परीक्षण उदाहरण)

— seshoumara
स्रोत

1

गणितज्ञ, 26 बाइट्स

शुद्ध कार्य जो अंकों की सूची लेता है और अंकों की सूची को आउटपुट करता है:

#/.{___,x_,y:0...}:>{x,y}&

व्याख्या

#                           First argument
 /.                           Replace
   {                              start of list followed by
    ___,                          zero or more elements followed by
        x_,                       an element (referred to later as x) followed by
           y:0...                 a sequence of zero or more 0s (referred to later as y) followed by
                 }                end of list
                  :>            with
                    {x,y}         {x,y}
                         &   End of function.

यह तब से काम करता है जब यह सबसे बाईं ओर का मैच पाता है x, जो कि सूची का सबसे सही नॉनजेरो तत्व होना चाहिए, क्योंकि इसके बाद अधिक 0s के शून्य का क्रम होता है और फिर सूची का अंत होता है।

— ngenisis
स्रोत

1

जावा 8, 47 बाइट्स

यह एक लैम्ब्डा अभिव्यक्ति के लिए उपयुक्त है IntUnaryOperator:

x->{int m=1;for(;x%m<1;m*=10);return x%m*m/10;}

स्पष्टीकरण: 10 तक गुणा m तक x%mनहीं है। 0. return x%m*m/10विभाजन की आवश्यकता है क्योंकि m वांछित परिणाम से अधिक परिमाण का एक आदेश है।

— जैक अम्मो
स्रोत

1

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

{+m/.0*$/}

तुच्छ रेगेक्स समाधान। इनपुट और आउटपुट एक नंबर।

— SMLS
स्रोत

1

MATL , 10 7 बाइट्स

@ बाइट की बदौलत 3 बाइट बच गए । मेहता!

tfX>Jh)

इनपुट और आउटपुट अंकों की एक सरणी है।

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

या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

t     % Input string implicitly. Duplicate
f     % Push indices of non-zero digits
X>    % Keep maximum, say k
Jh    % Attach 1j to give [k, 1j]. This is interpreted as an index "k:end"
)     % Index into original string. Display implcitly

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

चूंकि हम पूर्णांक के वेक्टर के रूप में इनपुट और आउटपुट लेने की अनुमति देते हैं, आप 48-3 बाइट्स को बचाते हुए पूरी तरह से हटा सकते हैं : इसे ऑनलाइन आज़माएं!

— बी। मेहता

1

सी #, 30 28 बाइट्स

इस जावास्क्रिप्ट उत्तर के आधार पर , मुझे लगता है कि सभी क्रेडिट थोड़े उसके पास जाते हैं।

golfed

i=a=>a%10<1?10*i(a/10):a%10;

-2 को हटाने के द्वारा बाइट्स ()चारों ओर aकरने के लिए धन्यवाद Emigna

— Metoniem
स्रोत

1

मुझे लगता है कि आपको इसके लिए फ़ंक्शन को स्पष्ट रूप से नाम देने की आवश्यकता है iक्योंकि आप पुनरावृत्ति का उपयोग कर रहे हैं।

— Emigna

@Emigna तुम सही हो! मैं पूरी तरह से चूक गया :(

— Metoniem

इसे अपडेट करें लेकिन मुझे 100% यकीन नहीं है अगर यह इस तरह से सही है

— Metoniem

1

मैं इस पर C # में आम सहमति नहीं जानता। यह वाक्यविन्यास मान्य है, लेकिन केवल तभी काम करेगा जब प्रतिनिधि पहले ही घोषित किया गया हो (अन्यथा iपुनरावर्ती कॉल के लिए अघोषित होगा)।

— एमिगा

1

हालांकि चारों ओर कोष्ठक की aआवश्यकता नहीं है।

— एमिगा

1

जे, 27 बाइट्स

10&|`(10*(p%&10))@.(0=10&|)

यह xnor के फॉर्मूले पर आधारित है, इसलिए उसे श्रेय जाता है।

— ब्लाकों
स्रोत

1

कोटलिन, 49 बाइट्स

लैम्ब्डा, के लिए असाइन किया गया (List<Int>) -> List<Int>

{a->a.slice(a.indexOfLast{it in 1..9}..a.size-1)}

अंतर्निहित पैरामीटर नाम itमेंindexOfLast
.. पर्वतमाला के निर्माण के लिए

— succcubbus
स्रोत

1

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

11, -nEइसके बजाय 1 के लिए-e

say/(.0*$)/

— msh210
स्रोत

1

05AB1E , 9 बाइट्स

RD0Ê1k>£R

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

R          # reverse input
 D         # duplicate
  0Ê       # check each for inequality with 0
    1k     # get the index of the first 1
      >    # increment
       £   # take that many digits from the input
        R  # reverse

— Emigna
स्रोत

इसे ऑनलाइन आज़माएं! - 6 बाइट्स

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

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

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

@MagicOctopusUrn: यह केवल अंतिम अंक की जाँच कर रहा है। यह अंतिम गैर-शून्य अंक और सभी के बाद होना चाहिए।

— एमिग्ना

1

जाप , 6 बाइट्स

f".0*$

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

— ओलिवर
स्रोत

1

स्टैक्स , 5 बाइट्स

æΩ$3╚

इसे चलाएं और डीबग करें

प्रक्रिया:

"गुणा" की गणना 10.
1 जोड़ें।
के कई पात्रों को रखें (स्ट्रिंग के रूप में इनपुट)।

— पुनरावर्ती
स्रोत

1

05AB1E , 4 बाइट्स

ĀÅ¡θ

I / O अंकों की सूची के रूप में।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें (परीक्षण सूट में बेहतर पठनीयता के लिए शामिल है)।

स्पष्टीकरण:

Ā     # Python-style truthify each digit in the (implicit) input-list (0 if 0; 1 if [1-9])
      #  i.e. [9,0,4,0,3,0,0] → [1,0,1,0,1,0,0]
 Å¡   # Split the (implicit) input-list on truthy values (1s)
      #  i.e. [9,0,4,0,3,0,0] and [1,0,1,0,1,0,0] → [[],[9,0],[4,0],[3,0,0]]
   θ  # And only leave the last inner list
      #  i.e. [[],[9,0],[4,0],[3,0,0]] → [3,0,0]
      # (after which it is output implicitly as result)

— केविन क्रूज़सेन
स्रोत

0

पाइके, 13 11 10 बाइट्स

`1QY0mN%e>

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

  QY       -     digits(input)
    0mN    -    map(^, i != 0)
 1     %   -   indecies(^, i == 1)
        e  -  ^[-1]
`        > - str(input)[^:]

11 बाइट्स:

`D\0mN1R%e>

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

13 बाइट्स:

`D\0mN_1R@_t>

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

— नीला
स्रोत

0

हास्केल 57 बाइट्स

f(x:s)a|x=='0'=f s$'0':a|1>0=x:a
t x=f(reverse.show$x)[]

Input    -> Output
t 120    -> "20"
t 30200  -> "200"

— ब्रांडर
स्रोत

कुशल गणना

चुनौती

उदाहरण

नियम

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

जेली , 6 3 बाइट्स

कैसे?

सी, 30 29 27 बाइट्स

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

क्यूबिक्स , 18 32 बाइट्स

जावास्क्रिप्ट, 21 बाइट्स

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

जावास्क्रिप्ट 19 18 बाइट्स

बैश + कोरुटिल्स, 12

पीस , 5 बाइट्स

व्याख्या

ब्रेकीलॉग , 2 बाइट्स

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

विम, 19 बाइट्स

टीआई-बेसिक, 18 बाइट्स

आर, 33 बाइट्स

Zsh , 18 16 बाइट्स

बैश , 25 बाइट्स

GNU सेड , 17 14 + 1 (आर झंडा) = 15 बाइट्स

गणितज्ञ, 26 बाइट्स

व्याख्या

जावा 8, 47 बाइट्स

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

MATL , 10 7 बाइट्स

व्याख्या

सी #, 30 28 बाइट्स

golfed

जे, 27 बाइट्स

कोटलिन, 49 बाइट्स

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

05AB1E , 9 बाइट्स

जाप , 6 बाइट्स

स्टैक्स , 5 बाइट्स

प्रक्रिया:

05AB1E , 4 बाइट्स

पाइके, 13 11 10 बाइट्स

11 बाइट्स:

13 बाइट्स: