यह काफी सरल है, एक नंबर दिया n, से एक श्रृंखला बनाने 0के लिए n-1। वास्तव में, कई भाषाएं इस ऑपरेशन को एक बेसिन के रूप में प्रदान करती हैं।

निम्न CJam प्रोग्राम एक पूर्णांक को पढ़ता है, और फिर इस तरह की सीमा को प्रिंट करता है ( इसे ऑनलाइन आज़माएं! )।

ri,

ध्यान दें कि यह एक विभाजक के बिना संख्या को प्रिंट करता है ।

चुनौती

आपका कार्य इस प्रक्रिया को उल्टा करना है। आपको एक प्रोग्राम लिखना चाहिए, जो एक सीमा का प्रतिनिधित्व करने वाला एक स्ट्रिंग देता है, उस सीमा का उत्पादन करने के लिए उपयोग किए गए नंबर को लौटाता है।

विशेष विवरण

नंबर बिना किसी विभाजक के दिए गए हैं।
आप मान सकते हैं कि स्ट्रिंग एक मान्य श्रेणी बनाती है।
आप अपनी सीमा के लिए 0- या 1-आधारित अनुक्रमण का उपयोग कर सकते हैं।
आप मान सकते हैं कि एक सही आउटपुट कभी भी 32,767 से अधिक नहीं होगा (इसलिए एक वैध इनपुट की लंबाई 152,725 से अधिक नहीं होगी)।
आप मान सकते हैं कि एक सही आउटपुट हमेशा सकारात्मक होगा (इसलिए आपको 0 या नकारात्मक को संभालने की आवश्यकता नहीं है)।

यह कोड-गोल्फ है , इसलिए सबसे कम प्रतिस्पर्धी उत्तर (बाइट्स में मापा गया) जीतता है।

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

0 अनुक्रमित:

0123 -> 4
0 -> 1
0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100 -> 101

1 अनुक्रमित:

1234 -> 4
1 -> 1
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100 -> 100

— फल तोड़ना
स्रोत

क्या कोई अवरोही सीमाएँ हैं? क्या इसे नकारात्मक संख्याओं के लिए काम करने की आवश्यकता है?

— डैनियल

@ डैनियल नंबर का उल्लेख करना भूल गए; जोड़ा।

— बजे फल

4

क्या हमारे कार्यक्रमों को वास्तव में खाली स्ट्रिंग को संभालने की आवश्यकता है? मुझे लगता है कि हमें इसकी अनदेखी करने की अनुमति देना उचित होगा। कुछ उत्तर उस नियम से बिल्कुल भी लाभान्वित नहीं होते हैं।

— श्री एक्सकोडर

क्या आउटपुट संख्या का एक स्ट्रिंग प्रतिनिधित्व हो सकता है यानी मूल स्ट्रिंग से एक विकल्प के रूप में लिया जा सकता है?

— user2390246

@ user2390246 हां, यह ठीक है।

— फलदायी फल

11

प्रोलोग (एसडब्ल्यूआई) , 91 80 बाइट्स

0 अनुक्रमित।

X*L:-atom_length(X,L),
     between(0,L,Y),
     numlist(0,Y,B),
     atomic_list_concat(B,X)
     ;L=0.

पठनीयता के लिए नई कड़ियाँ जोड़ी गईं।

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

— Emigna
स्रोत

11

भूसी , 5 बाइट्स

LCmLN

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

केवल अक्षर!

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

व्याख्या

LCmLN
  mLN    get the list of lengths of all positive naturals
 C       cut the input into slices of those lengths
L        get the length of the resulting list

— सिंह
स्रोत

8

05AB1E , 7 6 बाइट्स

1 अनुक्रमित।

āηJsk>

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

व्याख्या

ā        # push range [1 ... len(input)]
 η       # compute prefixes of the range
  J      # join each prefix to a string
   sk    # get index of the input in the list of prefixes
     >   # increment

— Emigna
स्रोत

क्या मुझसे कुछ ग़लत हो रहा है? यह वापस जाने के लिए लगता है 0: कोई इनपुट बात tio.run/##MzBNTDJM/f8/3efcdi/PbLv//5UMjYxNTM3MLSwNDZQA

— शैगी

@Shaggy: आप की तरह यह क्या करना है इस या इस एकल उद्धरण इनपुट के हिस्से के रूप में गिनती के रूप में।

— एमिगा

आह, 05AB1E में स्ट्रिंग आदानों को ट्रिपल उद्धृत करने की आवश्यकता है?

— झबरा

@ शैगी: यदि आप इनपुट में खाली स्ट्रिंग या नयालाइन चाहते हैं। अन्यथा आपको इसे उद्धृत करने की आवश्यकता नहीं है।

— एमिगा

[NÝJQ#]Nमेरा विचार था, लेकिन यह बेहतर है क्योंकि यह काम करता है ""।

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

7

जावा 8, 66 59 बाइट्स

s->{int r=0;for(String c="";!c.equals(s);c+=r++);return r;}

0 अनुक्रमित

-7 बाइट्स @ PunPun1000 को धन्यवाद ।

मुझे लगता है कि इसे केवल किसी भी तरह से इनपुट की लंबाई की जांच करके छोटा किया जा सकता है, क्योंकि हम मान सकते हैं कि इनपुट हमेशा मान्य है। फिर भी यह पता लगाना। यह पता लगाने में असमर्थ है, और यह संभवतः जावा में बहुत सारे बाइट्स को वैसे भी उपयोगी बनाने के लिए खर्च करेगा (यह एक 1-अनुक्रमित इनपुट के अंत के एक विकल्प को वापस करने के लिए लागू होता है)।

स्पष्टीकरण:

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

s->{                 // Method with String parameter and integer return-type
  int r=0;           //  Result-integer
  for(String c="";   //  Check-String
      !c.equals(s);  //  Loop as long as the sum-String doesn't equal the input-String
    c+=r++           //   Append the number to the the Check-String,
                     //   and increase the Result-integer by 1
  );                 //  End of loop
  return r;          //  Return the result-integer
}                    // End of method

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

1

59 बाइट्स: TIO

— PunPun1000

वहाँ शायद कुछ बेतुका शॉर्टकट है जैसे लोगों की संख्या की गिनती या लंबाई के लघुगणक का उपयोग करने के लिए आवश्यक विकल्प की लंबाई प्राप्त करने के लिए ... मुझे केवल इसके लिए बुरे विचार हैं।

— जॉली जोकर

6

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

⟦kṫᵐc,Ẹ

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

0 अनुक्रमित।

व्याख्या

यहां हम आउटपुट चर के माध्यम से इनपुट पास करते हैं, और इनपुट चर के माध्यम से परिणाम तक पहुंचते हैं।

⟦          The result is the input to a range…
 k         …with the last element removed…
  ṫᵐ       …which when all elements are casted to string…
    c      …and are then concatenated results in the input string
     ,Ẹ    (Append the empty string, this is necessary for it to work in the case where the 
             input is the empty string)

— Fatalize
स्रोत

5

लाइ , 29 बाइट्स

iys&p>0<11[ppl>s1+<lfspSylL]>

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

विश्वास नहीं किया जा सकता है कि यह काम किया है ...

— LyricLy
स्रोत

5

जाप , 8 बाइट्स

जाप में फ़ंक्शन विधियों के साथ पकड़ना शुरू करना।

0 अनुक्रमित। एक स्ट्रिंग, एक पूर्णांक या 0 या 1 तत्वों वाले एक सरणी के रूप में इनपुट ले सकते हैं।

_o ¬¥U}a

झसे आज़माओ

व्याख्या

स्ट्रिंग का निहित इनपुट U।

_     }a

>=0किसी फ़ंक्शन से गुज़रने पर पहला पूर्णांक प्राप्त करें जो सही हो ...

0वर्तमान पूर्णांक की तुलना में 1 से पूर्णांक का एक सरणी उत्पन्न करता है ...

¬

इसे एक तार में शामिल करता है ...

¥U

के साथ समानता के लिए उस स्ट्रिंग की जाँच करता है U।

परिणामी पूर्णांक का निहित उत्पादन।

वैकल्पिक, 8 बाइट्स

ÊÇo ¬ÃbU

झसे आज़माओ

— झबरा
स्रोत

4

चारकोल , 13 बाइट्स

Ｉ⌕Ｅ⁺ψθ⪫ＥκＩλωθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

          λ     Inner map variable (μ inner map index also works)
         Ｉ      Cast to string
        κ       Outer map index
       Ｅ        Map over implicit range
      ⪫    ω    Join result
     θ          Input string
   ⁺ψ           Plus an extra character
  Ｅ             Map over each character
 ⌕          θ   Find the index of the original string
Ｉ               Cast from integer to string
                Implicit print

— नील
स्रोत

4

हास्केल, 40 37 बाइट्स

f s=[n|n<-[0..],(show=<<[0..n])>s]!!0

फ़ंक्शन जो शून्य-आधारित श्रेणियों को उलट देता है।

3 बाइट बचाने के लिए लकोनी के लिए धन्यवाद!

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

— क्रिस्टियन लुपस्कू
स्रोत

1

सूची बोध के साथ 37 बाइट्स f s=[n|n<-[0..],(show=<<[0..n])>s]!!0:।

— लकोनी

1

और बस इसका उल्लेख करने के लिए, आप दूसरे पैटर्न गार्ड का उपयोग करके एक बाइट बचा सकते हैं |m<-n+1=s!m:।

— लकोनी

4

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

+1`(\d+?)(?!\D)(?<!\1.+)
$0;
;

प्रत्येक संख्या के बाद पुनरावर्ती अर्धविराम जोड़ता है, फिर अर्धविरामों की संख्या गिनता है

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

— PunPun1000
स्रोत

2

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

चैलेंजर 5 के लिए 1 बाइट धन्यवाद

f=(s,r=n='')=>r<s?f(s,r+n++):+n

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

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

f=(s,r=n='')=>r<s?f(s,r+n++):+n

console.log(f('0123'))
console.log(f('0'))
console.log(f(''))
console.log(f('0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100'))

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

— Arnauld
स्रोत

1

फिर, क्या आप तार की तुलनात्मक रूप से कर सकते हैं?

— फलदायी फल

मैं करीने का सुझाव देने जा रहा था, लेकिन ऐसा लग रहा है कि अब यह आम सहमति नहीं है :(

— झबरा

1

@ शैगी उम्म, यह वास्तव में है ...

— एरिक आउटगोल्फर

1

@EriktheOutgolfer मानक करी ठीक है, लेकिन झबरा करी के इस विशेष रूप का उल्लेख कर रहा था जिसके लिए कॉल की आवश्यकता होती है जैसे कि f(payload_param)()या भी f(payload_param)(some_constant)। (संयोग से, मुझे यकीन नहीं है कि यह इस विशेष मामले में काम करेगा क्योंकि मुझे दोनों की आवश्यकता है rऔर nआरंभिक होना चाहिए।)

— अरनौल्ड

2

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

Array[""<>ToString/@Range@#&,2^15]~Position~#&

1 अनुक्रमित

इनपुट

[ "12345678910"]

— J42161217
स्रोत

2

रूबी , 51 50 46 बाइट्स

->n{(0..4e4).map{|x|(1..x).to_a.join}.index n}

(यह मेरा अब तक का पहला रूबी कार्यक्रम है इसलिए इसे आगे बढ़ाना आसान होना चाहिए)

-4 बाइट्स @ नन्हें को धन्यवाद

— Elazar
स्रोत

1

आपको कोष्ठक के अंतिम सेट की आवश्यकता नहीं है: .index(gets)=> .index gets। आप 4e4इसके बजाय उपयोग कर सकते हैं 8**5, हालांकि इससे यह और भी धीमा हो जाएगा। यह आम तौर पर ठीक है, और अक्सर कुछ बाइट्स बचाता है, रूबी के जवाब के लिए अनाम लंबोदा का उपयोग करने के लिए: इसे ऑनलाइन आज़माएं! (मैंने इस सीमा को 100 में बदल दिया ताकि यह समय समाप्त न हो।)

— नेन्स

2

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

f=lambda s,i=1,r='':r<s and-~f(s,i+1,r+`i`)

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

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

f=lambda s,i=1:s>''and-~f(s[len(`i`):],i+1)

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

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

lambda s:s[-sum(i*'0'in s for i in range(5)):]

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

एक अलग रणनीति। अंत में सबसे बड़े रन की लंबाई के बराबर के पात्रों की संख्या लेता है 0।

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

f=lambda s,c=0:c*'0'in s and f(s,c+1)or s[-c:]

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

उपरोक्त का पुनरावर्ती संस्करण।

— XNOR
स्रोत

क्या आपके "अलग रणनीति" (बहुत चालाक, btw) चुनौती के बयान में आवश्यक के रूप में 0-आधारित श्रेणियों के लिए काम करता है? क्या आपको आंतरिक बिट को बदलना चाहिए ... i*'0'in s[1:] for ...या ऐसा कुछ?

— लुका सिटी

@LucaCiti यह 1-आधारित श्रेणियों के लिए काम करता है, और चुनौती हमें चुनने देती है।

— xnor

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

— लुका सिटी

2

आर , 47 बाइट्स

n=nchar(scan(,""));which(cumsum(nchar(1:n))==n)

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

1 अनुक्रमित

— user2390246
स्रोत

3

"if"इसके बजाय का उपयोग करेंifelse

— Giuseppe

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

— user2390246

1

आप एक नंबर के रूप में इनपुट ले सकते हैं, जैसा ncharकि आप संख्याओं पर उम्मीद कर सकते हैं काम करता है। हालाँकि, आपको अपने आउटपुट को प्रिंट करने की आवश्यकता होती है, क्योंकि यह पूर्ण प्रोग्राम के रूप में नहीं चलेगा।

— JAD

1

n=nchar(scan());cat(which(cumsum(nchar(1:n))==n))

— JAD

2

एपीएल (डायलॉग) , 17 11 बाइट्स

-6 बाइट्स ngn के लिए धन्यवाद ।

{,\⍕¨⍳≢⍵}⍳⊂

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

⍳⊂में संपूर्ण तर्क के the ndex का पता लगाएं

{... } इस अनाम फ़ंक्शन का परिणाम:

≢ तर्क की लंबाई

⍳ ɩ ntegers जब तक कि

⍕¨ प्रारूप (कठोर) प्रत्येक

,\ उन का संचयी संघटन

— एडम
स्रोत

ओह, मैं भूल गया कि मैं सिर्फ लंबाई, अच्छी नौकरी से दूर जा सकता हूं।

— 18

{,\⍕¨⍳≢⍵}⍳⊂(11 वर्ण)

— ngn

@ मुझे मूर्खतापूर्ण। बेशक!

— अदम

2

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

18 बाइट्स कोड + 1 के लिए -p।

$i++while s/$i\B//

1-आधारित अनुक्रमण का उपयोग करता है। -7 धन्यवाद बाइट्स के लिए @ nwellnhof 's बहुत बेहतर दृष्टिकोण!

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

व्याख्या

$\एक विशेष चर है जो printप्रत्येक कथन के बाद स्वचालित रूप से एड होता है, इसलिए हमारी संख्या को स्टोर करने के लिए हमें वांछित आउटपुट को शामिल करने के लिए अपडेट करने की आवश्यकता नहीं है $_(जो स्वचालित रूप से -pध्वज की कार्यक्षमता के भाग के रूप में मुद्रित होता है )। फिर, इनपुट के साथ शुरू होने के बाद $\, इसे और redoप्रोग्राम को हटा दें , जो फिर से वृद्धि करता है $\और इसे बदलता है। जब यह स्ट्रिंग की शुरुआत में संख्या नहीं पाता है, तो हम कर रहे हैं! अंत में, वेतन वृद्धि $\इसलिए हमारे पास सीमा में अंतिम संख्या है।

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

$i++while s/$i\B//(18 + 1 बाइट्स) के बारे में क्या ?

— nwellnhof

@nwellnhof यह बहुत बेहतर है! मुझे लगता है कि मैंने एक अधिक जटिल मार्ग शुरू कर दिया क्योंकि मैंने उत्तर दिया 0-अनुक्रमित सबसे पहले ... धन्यवाद!

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

1

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

0 अनुक्रमित

l=lambda x,z="",y=0:z<x and l(x,z+`y`,y+1)or y

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

— हलवार्ड वुल्म
स्रोत

1

सीजेएम , 16 बाइट्स

r0({)_,s2$=!}g\;

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

वैकल्पिक 16 बाइट्स

r:V;0({)_,sV=!}g

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

— लीक नन
स्रोत

1

सीजेएम , 13 बाइट्स

q:Q,),{,sQ=}#

इतने सारे अल्पविराम ...

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

व्याख्या

q:Q            Read the input and store it in Q
   ,           Get its length
    ),         Get the range 0..n
      {,sQ=}#  Find the index of the first number in the range to satisfy this block:
       ,        Get the range 0..(number)-1
        s       Stringify it
         Q=     Check if it equals the input

— बिजनेस कैट
स्रोत

1

पर्ल 6 , 30 28 27 बाइट्स

{first :k,*eq$_,[\~] '',0...*}

झसे आज़माओ

{[\~]('',0...*).first($_):k}

झसे आज़माओ

{first :k,$_,[\~] '',0...*}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  first       # find the first one
  :k,         # return the index into the Seq instead of what matched
  $_          # that matches the input

  # from the following

  [\~]        # triangle reduce using &infix:«~» (string concatenation)

              # a Seq
    '',       #   that starts with an empty Str
    0         #   then a 0
    ...       #   generate values
    *         #   indefinitely
}

'',0...*मूल्यों की एक अनंत अनुक्रम का उत्पादन '', 0, 1, 2, 3...

[\~] '',0...* सभी संभावित आदानों के एक अनंत अनुक्रम का उत्पादन करता है

""
"0"
"01"
"012"
"0123"
...

ध्यान दें कि यदि आप इसे अमान्य इनपुट देते हैं तो यह कोड कभी बंद नहीं होगा।

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

अजगर , 11 10 बाइट्स

1 अनुक्रमित।

fqQ|jkSTk0

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

यदि खाली स्ट्रिंग को अनदेखा किया जा सकता है, तो इसे 6 बाइट्स तक छोटा किया जा सकता है :

fqQjkS

-1 बाइट थैंक्स टू @ मेनमोनिक

— मिस्टर एक्सकोडर
स्रोत

?QfqQjkUT)1यह 11 में भी कर सकते हैं, लेकिन मुझे लगता है कि कुछ reordering एक बाइट बंद कर सकते हैं। कोई विचार?

— डेव

आप jks`m के बजाय का उपयोग करके एक बाइट बचा सकते हैं ।

— मुनीमोनिक

1

CJam, 14 12 11 बाइट्स

q,_){,s,}%#

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

q,   e# Get length of input string
_)   e# Duplicate length, increment by 1
{    e# Generate array by mapping [0,1,2,...,length] using the following function: 
,    e# Generate range [0,x] (x is the int we're mapping)
s    e# Convert range to string (e.g [0,1,2,3] => "0123"
,    e# Get the length of that string
}%   e# Map the int to the length of it's range string
#    e# Return the index of the length of the input string in the generated array

— geokavel
स्रोत

1

डायविल , 42 38 बाइट्स

s=>"".{var r=0;while($0!=s)$0++=r++;r}

इस जावा उत्तर के रूप में एक ही एल्गोरिदम , इसके अलावा (एब) डायविल के कुछ वाक्यगत विशिष्टताओं का उपयोग करता है।

स्पष्टीकरण:

s=>          // starts a lambda expression with one parameter
"".{         // begins a brace access expression, the value before the '.'
             // is available within the braces as a variable named '$0'
var r=0;     // variable with inferred type int
while($0!=s) // while the accumulator $0 does not (structurally) equal s
$0++=r++     // concatenate $0 and the String representation of r,
             // then store the result in $0 and increment r by 1
;            // end of while
r}           // return r as the result of the lambda

4संचायक के लिए एक चर के बजाय ब्रेस एक्सेस अभिव्यक्ति का उपयोग करके बाइट्स को बचाया

— Clashsoft
स्रोत

मस्त भाषा !!

— रॉबर्ट फ्रेजर

0

MATL , 14 बाइट्स

`@q:VXzGX=~}@q

1 अनुक्रमित।

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

व्याख्या

`       % Do...while
  @     %   Push iteration index (1-based), k
  q     %   Subtract 1: gives k-1
  :     %   Range: [1 2 ... k-1]. Will be empty for k=1
  V     %   Convert to string
  Xz    %   Remove spaces
  G     %   Push input
  X=    %   Are the two strings equal?
  ~     %   Negate. This is the loop condition. If true: next iteration
}       % Finally (execute at the end of the loop)
  @     %   Push k
  q     %   Subtract 1: gives k-1. This is the solution
        % End (implicit). Display (implicit)

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

1

रुको, चारकोल ने MATL को हराया?

— नील

0

सी # , 72 बाइट्स

डेटा

इनपुट String i अंत सरणी को डिक्रिप्ट किया जाएगा
आउटपुट Int32 सरणी बनाने के लिए उपयोग की जाने वाली संख्या

golfed

(string i)=>{int c,p=c=0;for(;p<i.Length;c++)p+=(c+"").Length;return c;}

Ungolfed

( string i ) => {
    int
        c,
        p = c = 0;

    for( ; p < i.Length; c++ )
        p += ( c + "" ).Length;

    return c;
}

अनपढ़ पठनीय

// Takes the string with the int array
( string i ) => {
    int
        c,         // Counter, it will count how many ints the array has.
        p = c = 0; // Padding, it will help jumping from int to int on the string.

    // Start counting. If 'i' is empty, the 'c' will be 0.
    for( ; p < i.Length; c++ )

        // Increase the number of digits with the length of 'c'.
        p += ( c + "" ).Length;

    // Return the counter.
    return c;
}

पूर्ण कोड

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestBench {
    public static class Program {
        private static Func<String, Int32> f = ( string i ) => {
            int
                c,
                p = c = 0;

            for( ; p < i.Length; c++ )
                p += ( c + "" ).Length;

            return c;
        };

        static void Main( string[] args ) {
            List<String>
                testCases = new List<String>() {
                    "0123",
                    "0",
                    "",
                    "0123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
                };

            foreach(String testCase in testCases) {
                Console.WriteLine($" Input: {testCase}\nOutput: {f(testCase)}\n");
            }

            Console.ReadLine();
        }
    }
}

विज्ञप्ति

v1.0 - 72 bytes- प्रारंभिक समाधान।

SOGL V0.12 , 11 10 9 बाइट्स

1 अनुक्रमित।

I∫HΔ∑=?f←

यह कोशिश करो!

स्पष्टीकरण:

I∫         repeat input+1 times
  HΔ         create a range from 1 to the 0-indexed iteration, inclusive
    ∑        join it
     =?      if it's equal to the input
       f←      exit, pushing the 0-indexed counter

.. और खाली मामले के बिना 7 बाइट्स

∫Δ∑=?F←

यह कोशिश करो!

— dzaima
स्रोत

0

एसीटो , 27 25 बाइट्स

1-आधारित सूचकांक।

;L[¥
`=]z
MLdI<
r!`;   p

हम rइनपुट को ead करते हैं और Mइसे emorize करते हैं (और सीधे Lइसे फिर से ओड करते हैं ), फिर हम इसे नकारात्मक करते हैं ( , !केवल एक खाली स्ट्रिंग के लिए एक सत्य मूल्य के लिए अग्रणी)। यदि यह मान सत्य है ( `), तो हम अंत में कूदते हैं ( ;), जहां हम pनिहित शून्य को रिंट करते हैं।

अन्यथा, हम वर्तमान स्टैक वैल्यू (शुरू में एक शून्य) बढ़ाते हैं, इसे डुप्लिकेट करते हैं, और स्टैक पर एक कॉपी दाईं ओर डालते हैं, जबकि वहां भी चल रहा है ( Id])। हम तब एक घटती सीमा ( z) का निर्माण करते हैं , स्टैक को एक स्ट्रिंग ( ¥) के रूप में जोड़ते हैं , और मूल स्टैक पर मान (और हमें) स्थानांतरित करते हैं ([ )। हम Lउस मूल्य को याद करते हैं जिसे हमने पहले (इनपुट) याद किया था और इस स्ट्रिंग के साथ तुलना की थी। यदि बराबर है, तो हम फिर से अंत में कूद जाते हैं, जहां हम वर्तमान "काउंटर" मान प्रिंट करते हैं (=`; ) ।

अन्यथा, बहुत सारी खाली जगह का पता लगाया जाता है जब तक कि हिल्बर्ट वक्र अंततः हिट नहीं करता है <जो आईपी को Iफिर से ऊपर रखता है , काउंटर को बढ़ाता है और फिर से परीक्षण करता है।

— L3viathan
स्रोत

0

स्टैक्ड , 23 बाइट्स

{!0$#+[::>''#`n=]until}

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

मूल रूप से, वृद्धि 0तब तक होती है जब तक कि 0संख्या से सीमा इनपुट की तरह दिखती है, पहले समानता के लिए जाँच।

— कोनोर ओ ब्रायन
स्रोत

0

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

JVṾẎ$$Ƥi

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

— आउटग्रॉफर को एरिक करें
स्रोत

अंकों की एक श्रृंखला को पूर्ववत करें

चुनौती

विशेष विवरण

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

प्रोलोग (एसडब्ल्यूआई) , 91 80 बाइट्स

भूसी , 5 बाइट्स

व्याख्या

05AB1E , 7 6 बाइट्स

जावा 8, 66 59 बाइट्स

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

व्याख्या

लाइ , 29 बाइट्स

जाप , 8 बाइट्स

व्याख्या

वैकल्पिक, 8 बाइट्स

चारकोल , 13 बाइट्स

हास्केल, 40 37 बाइट्स

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

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

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

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

रूबी , 51 50 46 बाइट्स

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

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

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

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

आर , 47 बाइट्स

एपीएल (डायलॉग) , 17 11 बाइट्स

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

व्याख्या

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

सीजेएम , 16 बाइट्स

वैकल्पिक 16 बाइट्स

सीजेएम , 13 बाइट्स

व्याख्या

पर्ल 6 , 30 28 27 बाइट्स

विस्तारित:

अजगर , 11 10 बाइट्स

CJam, 14 12 11 बाइट्स

डायविल , 42 38 बाइट्स

MATL , 14 बाइट्स

व्याख्या

सी # , 72 बाइट्स

डेटा

golfed

Ungolfed

अनपढ़ पठनीय

पूर्ण कोड

विज्ञप्ति

टिप्पणियाँ

SOGL V0.12 , 11 10 9 बाइट्स

एसीटो , 27 25 बाइट्स

स्टैक्ड , 23 बाइट्स

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