चुनौती

एक प्रतिवाद एक गैर-नकारात्मक पूर्णांक है, जिसके अंक सभी समान हैं।

एक फ़ंक्शन या पूर्ण प्रोग्राम बनाएं जो इनपुट के रूप में एक पूर्णांक लेता है और एक सत्य मान को आउटपुट करता है यदि इनपुट संख्या आधार 10 में एक प्रतिसंहिता है और अन्यथा गलत है।

इनपुट एक सकारात्मक पूर्णांक होने की गारंटी है ।

आप बेस 10 में एक स्ट्रिंग प्रतिनिधित्व के रूप में इनपुट ले सकते हैं और उपयोग कर सकते हैं।

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

ये सभी 1000 से नीचे की प्रतिपूर्ति हैं।

OEIS पर एक बड़ी सूची मिल सकती है ।

जीतना

बाइट्स में सबसे छोटा कोड जीतता है। कहने का तात्पर्य यह नहीं है कि क्रियात्मक भाषाओं में चतुर उत्तरों का स्वागत नहीं किया जाएगा।

— ऐडन एफ पियर्स
स्रोत

2

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

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

यह पूर्णांकों पर कार्य करता है।

से src/predicates.pl#L1151:

brachylog_equal('integer':0, 'integer':0, 'integer':0).
brachylog_equal('integer':0, 'integer':I, 'integer':I) :-
    H #\= 0,
    integer_value('integer':_:[H|T], I),
    brachylog_equal('integer':0, [H|T], [H|T]).

— लीक नन
स्रोत

मैंने इसे स्वीकार करने का फैसला किया है क्योंकि यह 1-बाइट प्रस्तुत करने वाला सबसे पुराना है।

— ऐदन एफ। पियर्स

19

सी (जीसीसी) , 33 30 29 बाइट्स

f(n){n=n%100%11?9/n:f(n/10);}

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

— डेनिस
स्रोत

इसके बजाय पुनरावृत्ति और असाइनमेंट के साथ बहुत अच्छी चाल return(लगता है कि मैं अपने उत्तर के लिए बाद में चोरी करने जा रहा हूं :))।

— दरवाज़े

@ डॉर्कनोब आगे बढ़ो। :) आपको हालांकि एक संकलक निर्दिष्ट करना होगा; मुझे उम्मीद है कि यह बहुत ज्यादा जीसीसी / टीसीसी ही होगा।

— डेनिस

आप पहले से जानते हैं कि साथ जीसीसी -O0के लिए अंतिम परिणाम लिखेंगे nवास्तव में से eaxहै, तो के रूप में यह वापसी मान बनाने के लिए? क्या आप तर्क पर विस्तार से बता सकते हैं कि आपको क्यों पता था कि यह काम करेगा?

— रुस्लान

@Ruslan मुझे यकीन नहीं है कि जीसीसी इस तरह का व्यवहार क्यों करता है, लेकिन एक फ़ंक्शन के अंदर अंतिम चर असाइनमेंट ईआरएक्स में अधिक बार नहीं की तुलना में हवा देता है। अगर मुझे अनुमान लगाना था, तो मैं कहूंगा कि यह return nएक शून्य होने की अनुमति देता है, और यदि आप परिणाम वापस नहीं करने जा रहे हैं, तो फ़ंक्शन के अंत में एक स्थानीय चर को असाइन करने का कोई कारण नहीं है।

— डेनिस

9

कॉबोल , 139 BYTES

मुझे लगता है कि COBOL को कोड गोल्फिंग में कोई प्यार नहीं मिलता है (शायद इसलिए कि इसे जीतने का कोई तरीका नहीं है) लेकिन यहाँ जाता है:

IF A = ALL '1' OR ALL '2' OR ALL '3' OR ALL '4' OR ALL '5' OR
ALL '6' OR ALL '7' OR ALL '8' OR ALL '9' DISPLAY "TRUE" ELSE   
DISPLAY "FALSE".

A को PIC 9 (4) के रूप में परिभाषित किया गया है।

— SaggingRufus
स्रोत

2

आप कर सकते हैं बदलकर इस गोल्फ TRUEऔर FALSEक्रमश: 1 और 0 के लिए

— coinheringaahing Caird

8

05AB1E , 1 बाइट

Ë

जांचें कि क्या सभी अंक समान हैं

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

— नील ए।
स्रोत

6

पायथन 3, 25, 24 19 बाइट्स।

len({*input()})>1>t

एक स्टड => त्रुटि कोड संस्करण।

त्रुटि कोड 0 लौटाता है यदि यह एक पुनरीक्षण है - या विफलता पर एक त्रुटि।

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

— साया
स्रोत

चूंकि निकास कोड 0 सफलता को इंगित करता है, मुझे लगता है कि आपको इसके >1बजाय परीक्षण करना चाहिए <2। वास्तविक त्रुटि को उठाना exitbtw का उपयोग करने से कम होगा ।

— डेनिस

मुझे इसके बारे में ही ख्याल आ रहा था। चुनौती कहती है "एक सत्य मूल्य"। मैं एक त्रुटि बढ़ाने के लिए इसे बदल दूंगा।

— छाया

1

हां, if python3 repdigit.py; then echo truthy; else echo falsy; fiबाहर की परिभाषा के अनुसार काम करना पड़ता है, इसलिए 0 सत्य है और बाकी सब कुछ गलत है।

— डेनिस

यह समझ आता है। ठीक है, मैं वह बदलाव कर दूंगा।

— छाया

2

@ Arc676 Unary *एक चलने योग्य है । उदाहरण के लिए, {*'123'}सेट उत्पन्न करता है {'1','2','3'}।

— डेनिस

6

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

AtomQ@Log10[9#/#~Mod~10+1]&

यह हरा नहीं करता है Equal@@IntegerDigits@#&, लेकिन यह अन्य अंकगणित-आधारित गणितज्ञ समाधान को हराता है ।

Repdigits फॉर्म n = d (10 ^m -1) / 9 के होते हैं जहाँ m अंकों की संख्या होती है और d दोहराए जाने वाले अंक होते हैं। हम इसे modulo 10 में ले कर n से d को पुनर्प्राप्त कर सकते हैं (क्योंकि यदि यह एक rep अंक है, तो यह अंतिम अंक d होगा )। तो हम इसे केवल m = log ₁₀ (9 n / (n% 10) + 1) के रूप में पुनर्व्यवस्थित कर सकते हैं और जाँच सकते हैं कि m पूर्णांक है या नहीं।

— मार्टिन एंडर
स्रोत

5

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

all=<<(==).head

इसे ऑनलाइन आज़माएं! स्ट्रिंग इनपुट लेता है।

के बराबर है \s->all(==head s)s। संकीर्णता से विकल्प निकलते हैं:

f s=all(==s!!0)s
f s=s==(s!!0<$s)
f(h:t)=all(==h)t
f(h:t)=(h<$t)==t
f s=(s<*s)==(s*>s)
f(h:t)=h:t==t++[h]

— XNOR
स्रोत

f s=(s<*s)==(s*>s)एक बहुत ही दिलचस्प विचार है, मुझे <*पहले के इस व्यवहार के बारे में पता नहीं था ।

— लैकोनी

5

सी (जीसीसी), 41 बाइट्स

f(char*s){s=!s[strspn(s,s+strlen(s)-1)];}

यह एक फ़ंक्शन है जो इनपुट को एक स्ट्रिंग के रूप में लेता है और 1अगर यह एक रेपिडिट है और 0अन्यथा।

यह strspnफ़ंक्शन का उपयोग करके ऐसा करता है , जो दो तार लेता है और पहले स्ट्रिंग के सबसे लंबे उपसर्ग की लंबाई देता है जिसमें दूसरे स्ट्रिंग से केवल वर्ण होते हैं। यहां, पहला स्ट्रिंग इनपुट है, और दूसरा स्ट्रिंग इनपुट का अंतिम अंक है, जो इनपुट स्ट्रिंग के अंतिम चरित्र को एक पॉइंटर पास करके प्राप्त किया जाता है।

Iff इनपुट एक रेपिडिट है, फिर कॉल का परिणाम strspnहोगा strlen(s)। फिर, sयदि यह मामला है ( str[strlen(str)]हमेशा है \0) या पहले अंक जो अंतिम अंक से मेल नहीं खाते हैं, तो एक अशक्त बाइट वापस करेगा । !परिणाम के साथ यह नकारना कि sएक प्रतिनिधि का प्रतिनिधित्व करता है।

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

@Dennis के लिए धन्यवाद, अप्रत्यक्ष रूप से मुझे याद दिलाने के बजाय 4-बाइट्स बचाते हुए, अपने पागलपन भरे जवाब से वापसी की चाल को याद दिलाया !

— Doorknob
स्रोत

आप इसे थोड़ा और टाल सकते हैं strlenऔर इससे एक नई *sc;f(char*s){c=*s;c=!s[strspn(s,&c)];}

— कड़ी बना सकते हैं

5

पीएचपी, २५ २ 25 २५

<?=!chop($argn,$argn[0]);

दाईं ओर से सभी वर्णों को हटा दें जो पहले के बराबर हैं और 1यदि सभी वर्ण हटा दिए गए थे तो प्रिंट करें ।

— क्रिस्टोफ
स्रोत

5

आर, 31 बाइट्स

function(x)grepl("^(.)\\1*$",x)

यह कार्य स्ट्रिंग इनपुट्स के साथ काम करता है और यह निर्धारित करने के लिए एक नियमित अभिव्यक्ति का उपयोग करता है कि इनपुट एक पुनरीक्षण है या नहीं।

उदाहरण

> f <- function(x)grepl("^(.)\\1*$",x)
> x <- c("1", "2", "11", "12", "100", "121", "333")
> f(x)
[1]  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE

— स्वेन होहेंस्टीन
स्रोत

समारोह (एक्स) से स्कैन का उपयोग कर ( ',') tio.run/##K/r/P70otSBHQylOQ08zJsZQS0VJpzg5MU9DR11dU/O/paXlfwA में स्विच करके 28 बाइट्स

— Sumner18

5

/// , 110 बाइट्स

/11/1//22/2//33/3//44/4//55/5//66/6//77/7//88/8//99/9//1/.//2/.//3/.//4/.//5/.//6/.//7/.//8/.//9/.//T..///.//T

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

/// भाषा में सत्य और असत्य की कोई अवधारणा नहीं है, इसलिए यह "T" आउटपुट करता है यदि इनपुट एक रेपिडिट है, और कोई भी वर्ण आउटपुट नहीं करता है यदि इनपुट रेपिडिट नहीं है।

— टान्नर स्विट
स्रोत

4

जेली , 2 1 बाइट

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

— डेनिस
स्रोत

2

उम्म ... करते हैं 1- 9repdigits के रूप में गिनती?

— आउटगोल्फ

2

ओपी के जवाब के मुताबिक , हां। वोल्फ्राम और OEIS सहमत हैं।

— डेनिस

4

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

@(s)s==s(1)

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

इनपुट को एक स्ट्रिंग के रूप में लेता है।

यह पहले पात्रों के साथ समानता के लिए सभी पात्रों की जांच करता है। यदि सभी समान हैं, तो परिणाम केवल 1(सप्तक में सच) के साथ एक वेक्टर होगा, अन्यथा कम से कम एक 0(ऑक्टेव में झूठा) होगा। यहाँ एक प्रमाण है ।

— स्टीवी ग्रिफिन
स्रोत

क्या आपको all(...)एक सत्य / मिथ्या मूल्य आउटपुट प्राप्त करने के लिए इसे लपेटने की आवश्यकता नहीं होगी ?

— टॉम कारपेंटर

क्या आपने सबूत का परीक्षण किया? कोड का टुकड़ा ppcg पर सही / गलत की परिभाषा (मेटा सर्वसम्मति) है।

— स्टिव ग्रिफिन

4

grep, 17 बाइट्स

grep -xP '(.)\1*'

किसी भी स्ट्रिंग से मेल खाता है जो उसके पहले चरित्र की पुनरावृत्ति है।

— टोबी स्पाईट
स्रोत

4

सी #, 42 33 28 बाइट्स

i=>i.Replace(i[0]+"","")==""

i एक तार होना चाहिए।

@LethalCoder का बहुत बहुत धन्यवाद

— LiefdeWen
स्रोत

2

i[0].ToString()से छोटा किया जा सकता है i[0]+"", <1की तुलना में कम है ==0।

— द लीथल कोडर

1

इसके अलावा .Length<1बस हो सकता है==""

— TheLethalCoder

3

ब्रिंगोल्फ , 6 बाइट्स

iul1-n

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

दुर्भाग्य से, कमांडिंग आर्ग से ब्रिंगोल्फ के अंतर्निहित इनपुट को स्ट्रिंग के रूप में सभी अंकों के इनपुट को स्वीकार नहीं किया जा सकता है, इसे हमेशा एक नंबर पर डाल दिया जाएगा, इसलिए इसके बजाय समाधान को STDIN से गुजरना होगा, जो STIN पढ़ने के लिए 1 बाइट जोड़ता है ( i)

स्पष्टीकरण:

iul1-n
i       Read from STDIN as string, push each codepoint to stack
 u      Remove duplicates from stack
  l     Push length of stack
   1-   Subtract 1
     n  Boolean negate, replace each item on stack with 1 if it is a python falsey value
        replace each item on stack with 0 if it is a python truthy value
        Implicit output of last item on stack

बाद में u, स्टैक की लंबाई इनपुट में अद्वितीय वर्णों की संख्या के बराबर होती है, 1 घटाना इसका मतलब है कि 0अगर और केवल अगर इनपुट में बिल्कुल 1 अद्वितीय चरित्र है 0, तो पायथन में एकमात्र गलत संख्या है, इसलिए, इसके साथ nप्रतिस्थापित करेगा , और बाकी सब कुछ ।010

— Skidsdev
स्रोत

3

जाप , 4 बाइट्स

¥çUg

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

— टॉम
स्रोत

3

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

नील को धन्यवाद देकर 2 बाइट्स बचाए

इनपुट को पूर्णांक या स्ट्रिंग के रूप में लेता है। एक बूलियन देता है।

n=>/^(.)\1*$/.test(n)

डेमो

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

let f =

n=>/^(.)\1*$/.test(n)

console.log(f(444))
console.log(f(12))

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

— Arnauld
स्रोत

2 बाइट बचाने के testबजाय का उपयोग नहीं करता है !!exec?

— नील

(हालांकि, स्ट्रिंग-ओनली इनपुट के लिए, PHP उत्तर को पोर्ट करना और भी कम है।)

— नील

@ मुझे नहीं पता कि मैं क्या सोच रहा था। धन्यवाद!

— अरनुलद

3

ओम , 4 बाइट्स

Ul2<

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

व्याख्या

 Ul2<
 U    # Push uniquified input
  l   # Length
   2< # Is it smaller than 2?

— Datboi
स्रोत

मुझे लगता है कि Ul≤काम करना चाहिए।

— क्रिस्टोफ

@Christoph Yee मेरे पास था लेकिन मुझे यकीन नहीं था कि 0 एक सत्य मूल्य के रूप में गिना जाता है। (इस कोडगॉल्फ बात के लिए काफी नया ^ ^)

— डेट्बोई

आह लानत 0झूठी है और हर दूसरे नंबर पर सच्चाई है। मैंने अभी देखा कि हमें इस चुनौती के लिए बिल्कुल विपरीत की आवश्यकता है (अक्सर जब तक हम यह घोषित करने की अनुमति देते हैं कि कौन सा मामला सत्य है और कौन सा गलत है)। ट्रुथ द्वारा परिभाषित किया गया है "एक खाई ले जाएगा"।

— क्रिस्टोफ

Ul1Eयह भी काम करना चाहिए (हालांकि मुझे ओम पता नहीं है) क्योंकि इसे संभालने की जरूरत नहीं है 0.

— Esolanging Fruit

3

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

2 बाइट्स ने @KritiiLithos को धन्यवाद दिया

⍕≡1⌽⍕

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

— Uriel
स्रोत

आप एक ट्रेन का उपयोग करके 7 बाइट के समाधान को 5 बाइट्स के लिए गोल्फ कर सकते हैं ⊢≡1⌽⊢।

— कृति लिथोस

@KritiiLithos धन्यवाद!

— एरियल

बदलें ⊢साथ ⍕दोनों तार और संख्या को संभालने के लिए।

— आदम

@ Adám धन्यवाद! मैंने अंकों की सरणी प्राप्त करने के तरीके के रूप में प्रारूपण के बारे में नहीं सोचा था।

— उरेल

3

जावा, 21 बाइट्स:

l->l.toSet().size()<2

lएक है MutableList<Character>ग्रहण संग्रह से।

— नाथन मेरिल
स्रोत

1

lएक चार एडेप्टर भी हो सकता है।

— डोनाल्ड राब

@ डोनाल्डराब ऊह, मैंने उस वर्ग को कभी नहीं देखा। अच्छा लगा।

— नाथन मेरिल

इसमें CodePointAdapter और CodePointList भी है।

— डोनाल्ड रबाब

1

@ डोनल्डरैब मैं ग्रहण संग्रहों का काफी उपयोग करता हूं, लेकिन मैं हमेशा मानक सूची / मानचित्र / सेट संग्रह के बाहर कुछ भी खोजने के लिए संघर्ष करता हूं। क्या आपका ज्ञान पुस्तकालयों के विकास पर आधारित है, या कहीं और है (जावदोक के अलावा) मुझे ईसी प्रदान करने वाली हर चीज के लिए बेहतर संदर्भ मिल सकता है?

— नाथन मेरिल

सुन के अच्छा लगा। मैं ढांचे के लिए एक कमिटेटर हूं ... मैंने एक साल या उससे पहले इन विशेष स्ट्रिंग संबंधित कक्षाओं को लिखा था। एक संदर्भ गाइड है जिसके बारे में बहुत से लोगों को पता नहीं है। लाइब्रेरी में सुविधाओं के ढेरों के माध्यम से लोगों को सीखने और नेविगेट करने में मदद करने के लिए मैंने हाल ही में एक माइंड-मैप बनाया है। यह रेफरी के टीओसी की अंतिम कड़ी है। मार्गदर्शक। github.com/eclipse/eclipse-collections/blob/master/docs/…

— डोनाल्ड राब

3

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

{it.toSet().size<2}

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

एक Stringकारण के रूप में इनपुट लेता है

आप बेस 10 में एक स्ट्रिंग प्रतिनिधित्व के रूप में इनपुट ले सकते हैं और उपयोग कर सकते हैं।

व्याख्या

{
    it.toSet()     // create a Set (collection with only unique entries)
                   // out of the characters of this string
        .size < 2  // not a repdigit if the set only has one entry
}

आप इस तथ्य है कि यह एक लेता है पसंद नहीं है String, तो आप एक है कि एक लेता है हो सकता है Intके लिए 24 बाइट्स ।

{(""+it).toSet().size<2}

— snail_
स्रोत

3

रेगेक्स (ECMAScript), 31 बाइट्स

^(x{0,9})((x+)\3{8}(?=\3$)\1)*$

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

गणित रीगेक्स के लिए हमेशा की तरह, इनपुट को एकरी में ले जाता है (ध्यान दें कि समस्या दशमलव इनपुट के साथ तुच्छ है: बस ^(.)\1*$)।

स्पष्टीकरण:

^(x{0,9})           # \1 = candidate digit, N -= \1
(                   # Loop the following:
  (x+)\3{8}(?=\3$)  # N /= 10 (fails and backtracks if N isn’t a multiple of 10)
  \1                # N -= \1
)* $                # End loop, assert N = 0

— ग्रिमी
स्रोत

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

— 19

@Deadcode व्हाट्सएप मैं उस में डालना भूल गया, धन्यवाद!

— ग्रिमी

2

PHP, 30 बाइट्स

<?=($a=$argn).$a[0]==$a[0].$a;

— user63956
स्रोत

@ दादा नहीं। यह 4344 और 4434 की तुलना करेगा।

— user63956

ओह ठीक है, मेरा बुरा। धन्यवाद

— दादा

2

नीम , 1 बाइट

𝐐

बस जाँच करता है कि सभी तत्व समान हैं।

बिना बिलियन, 2 बाइट्स:

𝐮𝐥

स्पष्टीकरण:

𝐮     Calculate unique digits
 𝐥    Get the length

यह काम करता है क्योंकि केवल 1नीम में सत्य माना जाता है, और बाकी सब कुछ मिथ्या है।

वैकल्पिक रूप से, 4 बाइट्स के लिए:

𝐮𝐣μ𝕃

स्पष्टीकरण:

𝐮      Calculate unique digits
 𝐣      Join list into an integer
   𝕃   Check that is is less than
  μ    Ten.

कोशिश करो!

— Okx
स्रोत

2

सी, 38 बाइट्स

f(char*s){return*s^s[1]?!s[1]:f(s+1);}

पुन: एक स्ट्रिंग चलता है। यदि पहले दो अक्षर अलग हैं ( *s^s[1]) तो हम केवल तभी सफल होते हैं जब हम स्ट्रिंग के अंत में होते हैं ( !s[1]) अन्यथा हम अगली स्थिति में परीक्षण दोहराते हैं ( f(s+1))।

परीक्षण कार्यक्रम

#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%s: %s\n", *argv, f(*argv)?"yes":"no");
}

— टोबी स्पाईट
स्रोत

2

जावा, 38 33 23 बाइट्स

n->n.matches("(.)\\1*")

nएक String, स्वाभाविक रूप से है।

ध्यान दें कि स्ट्रिंग में खोजने की तुलना में ^...$सटीक मिलान (जैसे matchविधि) के लिए स्वचालित रूप से उपयोग किए जाने के बाद से रेगेक्स की कोई आवश्यकता नहीं है ।

कोशिश करो!

बचाता है

-5 बाइट्स: String"के बाद से आप इनपुट ले सकते हैं और इनपुट का उपयोग एक स्ट्रिंग के रूप में कर सकते हैं।"
-10 बाइट्स: रेगेक्स जाहिर तौर पर एक अच्छा फिट है।

— ओलिवियर ग्रेजायर
स्रोत

इस सटीक समाधान को पोस्ट करने के बारे में था, जिसमें matchesआवश्यकता नहीं होने के बारे में स्पष्टीकरण भी शामिल था ^$क्योंकि यह पूरे स्ट्रिंग से मेल खाता है। तो मुझसे एक निश्चित +1। ;)

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

2

आर, 25 बाइट्स

grepl("^(.)\\1*$",scan())

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

सबसे अच्छा गैर-रेग्ज समाधान मैं 36 बाइट्स के साथ आ सकता था:

is.na(unique(el(strsplit(x,"")))[2])

— user2390246
स्रोत

1

गैर-रेगेक्स पर एक और विकल्प के लिएrle(charToRaw(scan(,'')))$v[2]<1

— मिकी टन

2

क्यूबिक्स , 15 बाइट्स

uOn@ii?-?;.$@<_

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

    u O
    n @
i i ? - ? ; . $
@ < _ . . . . .
    . .
    . .

यह देखो भागो

सत्य के लिए आउटपुट 1 और फ़ासी के लिए कुछ भी नहीं

बहुत सरलता से एक समय में इनपुट एक वर्ण में पढ़ता है। यह वर्तमान चरित्र को पिछले से दूर ले जाता है। यदि एक गैर शून्य परिणाम होता है तो यह तुरंत रुक जाता है। अन्यथा यह ईओआई तक इनपुट करना और तुलना करना जारी रखता है। EOI (-1) पर, नकारात्मक और बाहर निकलें

— MickyT
स्रोत

2

QBasic 4.5, 55 बाइट्स

INPUT a
FOR x=1TO LEN(STR$(a))
c=c*10+1
NEXT
?a MOD c=0

मैंने इसे गणित किया है! फ़ोर-लूप इनपुट में अंकों की संख्या की जांच करता है, फिर बनाता है c, जो इनपुट के बराबर 1 की लंबाई की एक श्रृंखला है। यदि यह एक-स्ट्रिंग == 0 को मापता है तो एक संख्या फिर से दोहराई जाती है।

इसे ऑनलाइन आज़माएं! ध्यान दें कि ऑनलाइन दुभाषिया थोड़ा विचित्र है और मुझे कुछ बयान लिखने थे कि डॉस आधारित क्यूबेसिक आईडीई का विस्तार अपने आप हो जाएगा।

— steenbergh
स्रोत

क्या यह संख्या एक प्रतिगामी है?

चुनौती

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

जीतना

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

सी (जीसीसी) , 33 30 29 बाइट्स

कॉबोल , 139 BYTES

05AB1E , 1 बाइट

पायथन 3, 25, 24 19 बाइट्स।

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

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

सी (जीसीसी), 41 बाइट्स

पीएचपी, २५ २ 25 २५

आर, 31 बाइट्स

उदाहरण

/// , 110 बाइट्स

जेली , 2 1 बाइट

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

grep, 17 बाइट्स

सी #, 42 33 28 बाइट्स

ब्रिंगोल्फ , 6 बाइट्स

स्पष्टीकरण:

जाप , 4 बाइट्स

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

डेमो

ओम , 4 बाइट्स

व्याख्या

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

जावा, 21 बाइट्स:

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

व्याख्या

रेगेक्स (ECMAScript), 31 बाइट्स

PHP, 30 बाइट्स

नीम , 1 बाइट

सी, 38 बाइट्स

परीक्षण कार्यक्रम

जावा, 38 33 23 बाइट्स

बचाता है

आर, 25 बाइट्स

क्यूबिक्स , 15 बाइट्स

QBasic 4.5, 55 बाइट्स