मैं एक प्रतिपूर्ति कैसे प्राप्त कर सकता हूं?

Question

जब मैंने पहली बार इस चुनौती के बारे में सोचा था, तो मैंने कई घंटे पहले कितने प्रतिनिधि के सम्मान में:

इस तरह की संख्याएँ जो एकल अंकों के दोहराव से बनी होती हैं, उन्हें पुनरीक्षण कहते हैं । रेपिडिज मजेदार हैं! प्रत्येक शरीर अधिक खुश होगा यदि उनके पास रेप की राशि ¹ रेपिडिट but थी , लेकिन मैं अधीर हूं, इसलिए आपको रीपीडिट करने के लिए सबसे तेज़ तरीका खोजने में मेरी मदद करने की आवश्यकता है।

यहाँ आपकी चुनौती है:

प्रतिष्ठा का प्रतिनिधित्व करने वाले एक सकारात्मक पूर्णांक को देखते हुए, प्रतिनिधि की न्यूनतम राशि प्राप्त करने के लिए उन्हें पुन: प्राप्त करने की आवश्यकता होती है। उदाहरण के लिए, इस चुनौती को लिखने के समय, उपयोगकर्ता मार्टिन एंडर के पास 102,856 प्रतिनिधि थे। निकटतम पुन: अंक 111,111 है, इसलिए उसे लाभ प्राप्त करने की आवश्यकता होगी: 8255 प्रतिनिधि एक प्रतिनिधि के रूप में होना चाहिए।

चूंकि लोग प्रतिनिधि को खोना पसंद नहीं करते हैं, इसलिए हम केवल गैर-नकारात्मक परिवर्तनों पर विचार करेंगे। इसका मतलब यह है कि, उदाहरण के लिए, यदि कोई व्यक्ति 12 प्रतिनिधि पर है, 1 प्रतिनिधि खोने के बजाय, समाधान 10 प्रतिनिधि प्राप्त करना है। यह '0' को एक वैध आउटपुट होने की अनुमति देता है, क्योंकि जिस किसी के पास 111 प्रतिनिधि है वह पहले से ही एक रेपिडिट में है।

इनपुट और आउटपुट किसी भी उचित प्रारूप में हो सकते हैं , और चूंकि किसी भी स्टैक एक्सचेंज साइट पर 1 से कम प्रतिनिधि होना असंभव है, आप मान सकते हैं कि कोई भी इनपुट 1 से कम नहीं होगा।

नोट करने के लिए एक कॉर्नसेकस:

यदि किसी उपयोगकर्ता के पास 10 से कम प्रतिनिधि हैं, तो वे पहले से ही एक repdigit पर हैं, और इसलिए उन्हें '0' भी चाहिए।

परीक्षण IO:

#Input      #Ouput
8           0
100         11
113         109
87654321    1234567
42          2
20000       2222
11132       11090

मानक कमियां लागू होती हैं, और बाइट्स जीत में सबसे छोटा समाधान होता है!

Comments

@ डेनिस मैं नहीं देखता कि क्यों।

— DJMcMayhem

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

— DJMcMayhem

संबंधित: codegolf.stackexchange.com/q/73916/17602

— नील

@ColdGolf मुझे बहुत संदेह है कि विकिपीडिया जल्द ही किसी भी समय मर जाएगा, लेकिन मैंने कुछ और जानकारी जोड़ी।

— DJMcMayhem

@ ब्रायनह नो, सबसे छोटा प्रतिनिधि लाभ जो कि बाधाओं को बदल जाता है 5 है (प्रश्न अपवोट)। हालांकि, इस चुनौती के लिए, हम इस तथ्य की अनदेखी कर रहे हैं कि प्रतिनिधि को प्राप्त करने के लिए कुछ निश्चित मात्राएँ हैं। तो 110देना चाहिए 1, भले ही एक प्रतिनिधि हासिल करने का कोई तरीका नहीं है।

— DJMcMayhem

Answer 1

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

DE$1#_

आउटपुट एक सिंगलटन ऐरे है।

इसे ऑनलाइन आज़माएं! या अधिकांश परीक्षण मामलों को सत्यापित करें । TIO के लिए टेस्ट केस 87654321 बहुत धीमा है।

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

DE$1#_  Main link. Argument: n

   1#   Call the link to the left with argument k = n, n + 1, n + 2, etc. until one
        match is found, then return the matching k.
  $       Combine the two links to the left into a monadic chain.
D           Convert k to base 10.
 E          Test if all decimal digits are equal.
     _  Subtract n from the result.

Comments

वाह ... सभी ASCII। यह एक पहला है। क्या कोई अन्य जेली समाधान हैं जो सभी ASCII हैं? बस उत्सुक।

— clismique

यह एक और उस एक को खोजना आसान था। और भी हो सकते हैं।

— डेनिस

Answer 2

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

until(((==).head>>=all).show)(+1)>>=(-)

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

Answer 3

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

:.#++#==,

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

यह काफी प्रभावशाली है क्योंकि यह बाधाओं को अंकगणित का उपयोग करता है।

व्याख्या

:.            The list [Input, Output].
  #+          Both elements must be positive or zero.
    +         The sum of those two elements…
     #=       …must result in an integer where all digits are the same.
       =,     Assign a value that matches those constraints.

Comments

मैं प्यार करता हूँ कि कैसे Brachylog उत्तर की तरह पढ़ता है। की तरह, आप बस को परिभाषित: This is the answer you're looking for. Figure it out for me:)

— DJMcMayhem

@DJMcMayhem यह घोषणात्मक भाषाओं का शांत कारक है! (हालांकि यह हमेशा जादुई नहीं है: पी)

— घातक

बहुत बढ़िया समाधान! मुझे लगता है कि ब्रेजलॉग हमेशा एक कार्यक्रम के अंत में शेष सीएलपी (एफडी) चर का एक अंतर्निहित लेबलिंग प्रदर्शन कर सकता है। इसे प्राप्त करने के लिए, संपूर्ण निष्पादन को लपेटें call_reside_vars/2, CLP (FD) चर प्राप्त करें और उन्हें लेबल करें। उदाहरण के लिए call_residue_vars(Program, Vs0), include(fd_var, Vs0, Vs), label(Vs):। तुम क्या सोचते हो?

— मैट

@ मम थैंक्स! मैं कार्यक्रमों के अंत में अंतर्निहित लेबलिंग को संवर्द्धन की सूची में जोड़ दूंगा, क्योंकि मैं किसी भी स्थिति के बारे में नहीं सोच सकता, जहां कोई निष्पादन के अंत में एक चर का उत्पादन करना चाहेगा।

— घातक

हे ...

— लीके नन

Answer 4

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

def f(n):r=10**len(`n`)/9;print-n/r*-r-n

कम से कम दृष्टिकोण नहीं है, लेकिन बहुत कुशल है। Ideone पर इसका परीक्षण करें ।

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

इनपुट 10**len(`n`)राउंड के लिए 10 की निकटतम शक्ति तक एन । बाद में, हम परिणाम को 9 से विभाजित करते हैं । यह प्रतिफल 1… 1 को लौटाता है जिसमें n के रूप में कई अंक हैं । हम परिणाम को r में सहेजते हैं । उदाहरण के लिए, यदि n = 87654321 , तो r = 11111111 ।

वांछित प्रतिक्षेप एक बहु या आर होगा । यह तय करने के लिए, हम r द्वारा n का छत विभाजन करते हैं । पायथन 2 के डिवीजन ऑपरेटर फर्श के बाद से, यह नकारात्मक संकेत के साथ, सही निरपेक्ष मान के साथ प्राप्त किया जाएगा। उदाहरण के लिए, यदि n = 87654321 , तो यह वापस आ जाएगा/-n/r -8 ।

अंत में, हम प्रत्येक संख्या के लिए n में एक बार भागफल को दोहराने के लिए गणना किए गए भागफल को -r से गुणा करते हैं । उदाहरण के लिए, यदि n = 87654321 , यह 88888888 रिटर्न करता है , जो कि वांछित प्रतिक्षेप है।

अंत में, आवश्यक वेतन वृद्धि की गणना करने के लिए, हम पिछले परिणाम से n घटाते हैं । हमारे उदाहरण के लिए n = 87654321 , यह वांछित के रूप में 1234567 देता है ।

Comments

एक और 41 है lambda n:10**len(`n`)/9*-~int(`n*9`[0])-n। यह लगभग करने के लिए काम करता है lambda n:int(`n*9`[0]*len(`n`))-n, लेकिन अंक एक बहुत छोटा है और मुझे इसे ठीक करने का एक अच्छा तरीका नहीं दिखता है।

— xnor

क्या आप इस सूत्र के पीछे के तर्क की व्याख्या करना चाहेंगे? मुझे चकित करता है कि यह कैसा है O(1)।

— shooqie

@shooqie मैंने अपना उत्तर संपादित कर लिया है।

— डेनिस

@ क्या: हुह, यह वास्तव में दिलचस्प है। मैंने हमेशा उस बंद-सूत्र के सूत्र == को ग्रहण किया O(1), लेकिन मुझे लगता है कि यह समझ में आता है।

— शौकी

अद्भुत दृष्टिकोण। पायथन 2 के लिए बाइट्स के मामले में यह थोड़ा लंबा हो सकता है, लेकिन यह जावा 7 में 40 बाइट बचाता है , इसलिए धन्यवाद। :) ("यह कैसे काम करता है" भाग के लिए बहुत बहुत धन्यवाद।)

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

Answer 5

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

f=lambda n:1-len(set(`n`))and-~f(n+1)

Ideone पर इसका परीक्षण करें । ध्यान दें कि यह दृष्टिकोण परीक्षण मामले के लिए भी अक्षम है 87654321 के ।

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

अगर n पहले से ही एक प्रतिगामी है, 1-len(set(`n`))तो 0 वापस आ जाएगा क्योंकि आधार 10 में n के अंकों के सेट की लंबाई 1 होगी । इस मामले में, एफ रिटर्न 0 ।

यदि n एक repdigit नहीं है, f(n+1)रिकर्सिवली कॉल च की अगली संभव मूल्य के साथ एन । -~द्वारा च की वापसी मूल्य वृद्धि ( 0 जब एक repdigit पाया जाता है) 1 बार हर बार च को पुनरावर्ती कहा जाता है, इसलिए अंतिम वापसी मूल्य बराबर होता है जिसे च की संख्या कहा जाता है, अर्थात, समय की संख्या n को घटाना था एक प्रतिपूर्ति प्राप्त करें।

Comments

मैं इन चीजों के लिए कभी भी स्पष्ट नहीं हूं कि क्या Lलंबे समय तक संभाला जाना चाहिए।

— xnor

क्या, कैसे करता है-- यह ... आप नहीं कर सकते ... क्या? एक पल के लिए वहाँ मैं अपने 52 बाइट जवाब पर गर्व था ...

— DJMcMayhem

@ xnor: C में समाधानों को डिफ़ॉल्ट रूप से लंबे पूर्णांक के लिए काम करने की आवश्यकता नहीं है, इसलिए मैंने हमेशा पायथन के लिए उसी तरह सही माना।

— डेनिस

@DJMcMayhem मुझे इस तरह दिखता है जब तक कि यह संख्या के स्ट्रिंग प्रतिनिधित्व से निर्मित सेट के आकार की जांच के माध्यम से एक प्रतिपूर्ति नहीं पाता है। -~फ़ंक्शन द्वारा किए गए कॉल की संख्या को गिनने की अनुमति देता है।

— वैल्यू इंक

Answer 6

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

{($_...{[==] .comb})-1}

एक लैम्ब्डा जो इनपुट नंबर को तर्क के रूप में लेता है, और परिणाम देता है।

स्पष्टीकरण:

1. का उपयोग करता है ...इनपुट नंबर को बढ़ाने के लिए अनुक्रम ऑपरेटर का जब तक कि यह एक पुनरीक्षण तक नहीं पहुंचता है (पात्रों में इसके स्ट्रिंग प्रतिनिधित्व को विभाजित करके देखें और देखें कि क्या वे सभी समान हैं) ।
2. अनुक्रम की लंबाई से एक घटाता है।

Comments

परीक्षण को बदला जा सकता है/(.)$0*/

— जो किंग

Answer 7

जावा 7, 116 76 बाइट्स

int c(int i){int r=(int)Math.pow(10,(i+"").length())/9;return(-i/r-1)*-r-i;}

इस्तेमाल किया @Dennis 'अद्भुत दृष्टिकोण एक 40 बाइट्स द्वारा बाइट गिनती कम करने के लिए।

अनगढ़ और परीक्षण के मामले:

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

class Main{
  static int c(int i){
    int r = (int)Math.pow(10, (i+"").length()) / 9;
    return (-i / r - 1) * -r - i;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(87654321));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(11132));
  }
}

आउटपुट:

0
11
109
1234567
2
2222
11090

Comments

वास्तव में, आपका "इसे आज़माएं" प्रिंट को 1 देता है यदि आप इसे प्रिंट करने के बजाय 8 को फ़ीड करते हैं जैसा कि इसे करना चाहिए।

— SQB

@SQB आह तुम सही हो। हम्म, यह बहुत अजीब है, मेरी पोस्ट में आउटपुट के बाद से मैंने अपने आईडीई कंसोल से कॉपी-पेस्ट किया है ..

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

दूसरा अंतिम आउटपुट नहीं होना चाहिए 2222और चौथा आउटपुट होना चाहिए 12345678?

— 22

@DanTheMan आह, पिछले करने के लिए दूसरा वास्तव में होना चाहिए 2222बजाय 222। मैंने कोड में एक गलती को ठीक किया, लेकिन दुर्घटना से अभी भी यहां पुराने आउटपुट का उपयोग किया गया था। यह अब तय हो गया है। चौथे के रूप में, नहीं, यह होना चाहिए 123467(जैसा कि आप ओपी के प्रश्न पर भी देख सकते हैं)।

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

Answer 8

Pyth, 9 8 7 बाइट्स

1 बाइट @FryAmTheEggman को धन्यवाद।

-f@F`TQ

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

बहुत अकुशल, इनपुट से लेकर अगली रिपीजिट तक सभी नंबरों से लूप करता है।

Comments

@Emigna को सूचित करने के लिए धन्यवाद। यह ठीक से परीक्षण करने के लिए समय नहीं था।

— PurkkaKoodari

Answer 9

ब्रेन-आलोचना 690 358 बाइट्स

यहाँ मेरा उस पर जाना है

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

यह ऑनलाइन की कोशिश करो

व्याख्या

इनपुट की दूसरी प्रति बनाने से शुरू करें जो मूल से कम है। हम अगली प्रतिपूर्ति के लिए खोज के लिए प्रतिलिपि का उपयोग करेंगे। हम एक ही संख्या घटने के मामले में एक घटाते हैं

(({})[()])

आने वाले पाश को संतुष्ट करने के लिए एक धक्का। (एक शून्य नहीं होना चाहिए)

(())

यह लूप तब तक चलेगा जब तक कि स्टैक के शीर्ष पर एक रेपिगिट न हो

{

बकवास पॉप। उनके ऊपर एक "बूलियन" है जो लूप को चलाता है, क्योंकि अब इसकी आवश्यकता नहीं है कि हम इसे पॉप करते हैं।

{}

एक जोड़ें और शीर्ष पर डुप्लिकेट करें। प्रतिलिपि अपने अंकों में विघटित हो जाएगी।

(({}()))

जबकि नकल शून्य नहीं है ...

{

फिर से कॉपी करें

(({}))

मॉड 10 और दूसरे स्टैक पर जाएं

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

10 से विभाजित करें (पूर्णांक विभाजन)

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

}

उस पॉप को शून्य करें जो हमारी प्रति थी

{}

हमने अब संख्या को उसके आधार 10 अंकों में विघटित कर दिया है, इसलिए हम सभी अंकों के साथ ढेर पर स्वैप करते हैं।

<>

जबकि अग्रणी अंक शून्य नहीं है

{

हम स्टैक हाइट (यानी अंकों की संख्या) की एक प्रति उठाते हैं ...

(([])<

स्टैक पर प्रत्येक संख्या से एक को चुपचाप घटाएं

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

हमने जिस स्टैक की ऊंचाई को उठाया है, उसे नीचे रखें। (और दूसरे स्टैक पर स्वैप करें)

><>)

हम स्टैक की ऊँचाई का उपयोग उन सभी अंको को खींचने के लिए करते हैं जिन्हें हमने दूसरे स्टैक पर वापस उचित स्टैक पर रखा है।

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

वह शून्य पॉप जो हमारी स्टैक ऊंचाई थी

{}

अंकों के साथ स्टैक पर वापस स्वैप करें (या अंक क्या थे)

<>

अंत लूप

}

अब हमने अन्य सभी अंकों से शीर्ष अंक घटा दिया है। यदि सभी अंक मूल संख्या शून्य हैं (इनपुट नहीं है लेकिन हम जिस संख्या की जाँच कर रहे हैं) एक repdigit थी। ^{[उद्धरण वांछित]} । इसलिए हमें गैर-शून्य के लिए जांच करने की आवश्यकता है।

जबकि स्टैक की ऊंचाई शून्य नहीं है

([])
{
{}

यदि अंक शून्य नहीं है, तो इसे दूसरे स्टैक पर ले जाएं और इसे शून्य से बदलें।

{
(<({}<>)<>>)
}

इसे पॉप करें (अब यह एक शून्य है)

{}

अंत लूप

([])
}
{}

अन्य स्टैक पर डुबकी (डुह ..)

<>

स्टैक ऊंचाई माइनस दो की एक प्रति ले लो

(([][()()])<

जबकि स्टैक की ऊंचाई दो नहीं है (मूल और संचायक)

{
{}

ऊपर पॉप

{}

समय समाप्त करें

([][()()])
}
{}

स्टैक हाइट माइनस दो की हमारी कॉपी नीचे रखें। यह उन अंकों की संख्या को समाप्त करता है जो पहले अंक के समान नहीं हैं। दूसरे शब्दों में अगर यह शून्य है तो यह एक प्रतिक्षेपक है।

>)

यदि यह लूप समाप्त होता है, तो हमें एक प्रतिगामी मिल गया है

}

पॉप "बूलियन"

{}

मूल को प्रत्यावर्तन से घटाएं

({}[{}])

Comments

गंभीरता से, आप यह कैसे करते हैं? मैं सोच रहा था "ओह, मैं इसे ब्रेन फ्लैक में करना चाहूंगा, लेकिन मैं यह पता नहीं लगा सकता हूं कि यह कैसे निर्धारित किया जाए कि यह रेपिडिट है या नहीं"। यह पागलपन है! क्या आप इनमें से अधिकांश उत्तरों को उत्पन्न करने के लिए स्क्रिप्ट का उपयोग करते हैं?

— DJMcMayhem

@DJMcMayhem केवल अभ्यास नहीं। एक स्पष्टीकरण का पालन करेंगे।

— गेहूं जादूगर

@DJMcMayhem मुझे खेद है कि शायद मुझे समझ नहीं आया। 112 + 110 = 222?

— गेहूं जादूगर

मुझे क्षमा करें, आप पूरी तरह से सही हैं, मुझे नहीं पता कि मैं क्या कह रहा हूं। कृपया उस अंतिम टिप्पणी को अनदेखा करें।

— DJMcMayhem

Answer 10

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

a=b=input()
while len(set(str(a)))!=1:a+=1
print a-b

पायथन 2 में कई तरकीबें हैं जो इसे छोटा बनाती हैं। उदाहरण के लिए, इनपुट संख्यात्मक है, इसलिए हमें इंट में डालने की आवश्यकता नहीं है। (-5 बाइट्स) हमें a-b(-1 बाइट) के आसपास कोष्ठक लगाने की जरूरत नहीं है

सभी परीक्षण मामलों को सत्यापित करने के लिए इस स्क्रिप्ट का उपयोग करें:

def f(i):
    a=b=i
    while len(set(str(a)))!=1:a+=1
    return a-b

inputs = [8, 100, 113, 87654321, 42, 20000, 11132]
outputs = [0, 11, 109, 1234567, 2, 2222, 11090]

for i in range(len(inputs)):
    print(f(inputs[i]) == outputs[i])

आप इसे ऑनलाइन भी आज़मा सकते हैं!

Answer 11

GNU सेड, 223 + 1 (आर झंडा) = 224 बाइट्स

s/$/:0%/
:;y/:%/%:/
/^(.)\1*%/{s/.*%(.*):/\1/;q}
:f;s/9(@*:)/@\1/;tf
s/8(@*:)/9\1/;s/7(@*:)/8\1/
s/6(@*:)/7\1/;s/5(@*:)/6\1/
s/4(@*:)/5\1/;s/3(@*:)/4\1/
s/2(@*:)/3\1/;s/1(@*:)/2\1/
s/0(@*:)/1\1/;s/(^|%)(@*:)/\11\2/
y/@/0/;t

चलाएँ:

sed -rf repdigit.sed <<< "112"

आउटपुट:

110

यह एक शुद्ध सेड सॉल्यूशन है , अंकगणित को केवल नियमित अभिव्यक्ति का उपयोग करके सिम्युलेटेड किया जाता है। यह एल्गोरिथ्म इस प्रकार काम करता है:

1. पैटर्न अंतरिक्ष प्रारूप के लिए सेट है ^current_reputation:needed_reputation%$
2. मुख्य लूप के प्रत्येक पुनरावृत्ति में विभाजक स्विच किए जाते हैं:
   ए) आवश्यक_%: वृद्धि को लागू करता है ख) को लागू करता है
   :% current_reputation
3. यदि current_reputation "repdigit" है, तो जरूरी_प्रतिस्पर्धा मुद्रित होती है और कार्यक्रम समाप्त हो जाता है

Answer 12

जावा, 74 72 बाइट्स

int c(int i){int n=0;while(!(i+++"").matches("^(.)\\1*$"))n++;return n;}

(यदि अन्य जावा प्रविष्टि 76 बाइट्स है, तो यह एक है74 72, चूंकि यह है दो चार बाइट्स छोटी)।

वैसे भी, इनपुट में वृद्धि तब तक करें जब तक कि यह काउंटर को बढ़ाते समय एक पुनरीक्षण न हो। काउंटर लौटा दो।

हां, वे एक पंक्ति में तीन प्लस हैं, इनपुट बढ़ाने के लिए दो, एक को खाली करने के लिए एक स्ट्रिंग को संक्षिप्त करने के लिए।
नहीं, मैंने नहीं सोचा था कि यह दोनों के बीच की जगह के बिना कानूनी होगा, लेकिन आप वहां जाते हैं। यही आपके लिए एक टाइपो करेगा: एक बाइट छोटी।

थोड़ी देर के लिए फॉर-लूप का उपयोग करना बिल्कुल कई बाइट्स के समान है:

int c(int i){int n=0;for(;!(i+++"").matches("^(.)\\1*$");n++);return n;}

---

संपादित करें:

एक पुराने संस्करण को matches("^(\\d)\\1*$")एक पुनरीक्षण के लिए जांचना था, लेकिन जब से हमने सिर्फ एक स्ट्रिंग को एक इंट में परिवर्तित किया है, एक .मैच का उपयोग करना पर्याप्त है।

---

अनगढ़ और परीक्षण के मामले:

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

class Main{
  static int c(int i){
    int n=0;
    while(!(i++ + "").matches("^(.)\\1*$")) {
      n++;
    }
    return n;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(87654321));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(11132));
  }

}

आउटपुट:

0
11
109
1234567
2
2222
11090

Comments

हम आम तौर पर हमेशा छोरों के लिए उपयोग करने की सलाह देते हैं क्योंकि कभी-कभी आप एक बाइट को इस तरह से सहेजने का एक तरीका चुन सकते हैं कि आप थोड़ी देर के लूप का उपयोग नहीं कर सकते।

— नील

@ नील ठीक है, मुझे पता चलेगा कि मुझे यहाँ कैसे जाना है।

— SQB

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

— नील

@ नील आह, ठीक है।

— 4Q पर SQB

Answer 13

आर, 102 98 91 बाइट्स

a=scan(,'');i=0;while(length(unique(strsplit(a,"")[[1]]))!=1){a=paste(strtoi(a)+1);i=i+1};i

अधूरा:

a=scan(,'') #Asks for input
i=0         #Initialize i to 0, surprisingly

while(length(unique(strsplit(a,"")[[1]]))!=1) 
    #Splits the input into its digits,  
    #compute the length of the vector created by the function `unique`, which gives all the digits once.
    #as long as the this length is different from one :
{
a=paste(strtoi(a)+1) #Increases by one the value of the input (while messing around with its format)
i=i+1                           #Increases by one the value of the counter
}

i #Outputs the counter

प्रारूप ( as.numericऔरas.character ) के साथ आस-पास मेसिंग कुछ बाइट्स जोड़ता है, लेकिन आर वास्तव में लचीला नहीं है!

Answer 14

पर्ल, 40 + 1 ( -n) = 41 बाइट्स

/^(.)\1*$/&&say($v|0) or$_++&&++$v&&redo

यदि 0नंबर पहले से ही एक repdigit स्वीकार्य है, तो इसके बजाय कुछ भी नहीं छापना है, तो 37 बाइट्स पर्याप्त हैं:

/^(.)\1*$/&&say$v or$_++&&++$v&&redo

-n(1 बाइट) और -Eया -M5.010(मुक्त) के साथ दौड़ें :

perl -nE '/^(.)\1*$/&&say($v|0) or$_++&&++$v&&redo'

स्पष्टीकरण : कोड में दो प्रमुख भाग हैं: /^(.)\1*$/&&say$vऔर $_++&&++$v&&redo। पहले एक परीक्षण अगर $_एक रेपिडिट है; यदि हाँ, तो यह संख्या को हम मूल संख्या में जोड़ देता है ताकि इसे एक प्रतिरूप ( $v) बना सकें , और यदि नहीं, तो हमारे पास 1 था $_और दोनों के लिए $v, और शुरू करें।

Comments

41 बाइट्स प्रति, स्ट्रिंग की लंबाई से 1 अंक (या 1 अंक + 1 यदि कोई अंक 1 से बड़ा है) को डुप्लिकेट करता है, तो इनपुट घटाता है:perl -pe '@x=sort/./g;//;$_=(($x[-1]>$&)+$&)x+@x-$_'

— एरिक

Answer 15

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

f=(n,p=1)=>n<p?-~(n*9/p)*~-p/9-n:f(n,p*10)

व्याख्या: बाद pकी अगली शक्ति के रूप में पुन: गणना करता है । दोहराया जाने वाला अंक तब गणना की जाती है , और पुनर्मिलन बस है , जिसमें से परिणाम निम्नानुसार है।10n1+floor(9n/p)(p-1)/9

Answer 16

05AB1E , 10 6 बाइट्स

∞.Δ+Ë

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

व्याख्या

∞<      # from the infinite list of non-negative integers
  .Δ    # find the first number where
     Ë  # all digits are equal
    +   # after adding the input

Comments

-2 बाइट्स जो पोस्टिंग के समय अभी तक कोई संदेह नहीं थे: हटाने §और बदलने के ¹-लिए α। और यहाँ एक समान 8-बाइट विकल्प है:∞+.ΔÙg}α

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

Answer 17

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

o+`}ltIr)ot

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

            - o = 0
o+          -     o++ + input
  `         -    str(^)
   }        -   deduplicate(^)
    lt      -  len(^)-1
      I )   - if ^:
       r    -  goto_start()
         ot - o++ -1

Answer 18

दरअसल, 15 बाइट्स

;D;WXu;$╔l1<WX-

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

स्पष्टीकरण:

;D;WXu;$╔l1<WX-
;                dupe
 D;              decrement, dupe
   WXu;$╔l1<W    while top of stack is truthy:
    X              discard
     u             increment
      ;            dupe
       $╔l1<       1 if len(str(TOS)) > 1 else 0 (check if the string representation of the TOS contains only one unique digit)
                 after the loop, the stack will be [1 repdigit input]
             X   discard
              -  subtract input from repdigit

Answer 19

जेलिफ़िश , 20 बाइट्स

p
<
)\&&&~j<i
->N>u0

इसे ऑनलाइन आज़माएं! टीआईओ अब परीक्षण मामलों को नहीं संभाल सकता है, लेकिन पर्याप्त समय और स्मृति को देखते हुए, उन्हें भी काम करना चाहिए।

व्याख्या

• iइनपुट है, और <इसे घटाता है। यह मान बाईं ओर फ़ंक्शन को खिलाया जाता है।
• \> मान को बढ़ाता है (कम से कम एक बार) जब तक कि फ़ंक्शन दाईं ओर एक सत्य मूल्य नहीं देता है।
• परीक्षण फ़ंक्शन &चार कार्यों की एक रचना ( एस) है।
• 0~j स्ट्रिंग में कनवर्ट करता है।
• u डुप्लिकेट अंक निकालता है।
• > परिणामी स्ट्रिंग के सिर को हटाता है।
• Nतार्किक निषेध है: यह 1एक खाली स्ट्रिंग के लिए देता है , और 0गैर-खाली के लिए। इस प्रकार फ़ंक्शन एक rep-digit के लिए परीक्षण करता है, और इसका परिणाम \अगले rep-digit से गिनती है <i।
• )-परिणाम को फ़ंक्शन इनपुट से घटाता है, अर्थात <i।
• यह अंतर एक बंद है, इसलिए <इसे घटाता है। अंत में, pपरिणाम प्रिंट करता है।

Answer 20

PowerShell v2 +, 66 बाइट्स

param($n)for($x=+"$($n[0])";($y="$x"*$n.length)-lt$n;$x++){}+$y-$n

आमतौर पर गुड्स-फॉर-गोल्फ बहुत ढीली कास्टिंग के लिए पॉवरशेल यहां एक बड़ी गिरावट है।

$nएक स्ट्रिंग के रूप में इनपुट लेता है , और एक forलूप में प्रवेश करता है । सेटअप चरण के लिए, हम पहले वर्ण को बाहर निकालते हैं $n[0], लेकिन "$(...)"इंट के रूप में कास्टिंग करने +और सहेजने से पहले इसे वापस स्ट्रिंग में बदलना होता है$x । अन्यथा, बाद के अंकगणित चार-कोड के एएससीआईआई मूल्य का उपयोग करेंगे।

सशर्त जाँच करता है कि क्या एक स्ट्रिंग $n.length "$x"एस से निर्मित , अस्थायी रूप से संग्रहीत है $y, कम से कम है $n। तो जब तक यह नहीं है, हम वृद्धि करते हैं $x++, अगले लूप के लिए सशर्त स्थापित करते हैं।

उदाहरण के लिए, इनपुट के लिए, जब सशर्त पहली बार चेक किया जाएगा 123, का मान कम-से-कम होगा , इसलिए लूप जारी रहता है। लूप बॉडी में कुछ भी नहीं है, इसलिए चरण वृद्धि होती है , फिर सशर्त को फिर से जांचा जाता है। यह समय बराबर होता है , जो इससे अधिक है , इसलिए लूप समाप्त हो जाता है। यदि इनपुट पहले से ही एक प्रतिगामी है, तो सशर्त संतुष्ट नहीं है, क्योंकि उस बिंदु पर बराबर है ।$y111$n$x++$y222$n$y$n

लूप से बाहर निकलने के बाद, हम $yएक पूर्णांक पर जाते हैं +, फिर घटाते हैं $n। यह परिणाम पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

Answer 21

PHP 5.6, 59 53 51 50 बाइट्स

सहेजे गए 6 8 बाइट्स @manatwork के लिए धन्यवाद।

while(count_chars($argv[1]+$b,3)[1])$b++;echo$b?:0

इसके साथ टेस्ट करें:

php test.php 11132

count_chars()दूसरा पैरामीटर के रूप में 3 के साथ समारोह एक स्ट्रिंग में अलग पात्रों के साथ एक स्ट्रिंग देता है। जब यह स्ट्रिंग 1 वर्ण लंबा होता है ( [1]लंबाई 1 होने पर यह झूठी लौटेगा) तो प्रतिध्वनि $b, अन्यथा वृद्धि $bऔर लूप फिर से।

Comments

का ठंडा उपयोग count_chars()। $ मोड पैरामीटर के रूप में 3 के बारे में क्या? तो यह whileशर्त होगी count_chars($argv[1]+$b,3)[1]:।

— मैनटवर्क 16

यह वास्तव में चालाक है, विचार के लिए धन्यवाद। मैंने मूल रूप से मोड के लिए 3 का उपयोग करने की कोशिश की, लेकिन इसके बिना उपयोग करने का एक तरीका नहीं सोच सकता था countया strlenइसलिए यह एक ही लंबाई निकला।

— सैमसक्च

ओह, और $ b को शुरू किए बिना:echo$b?:0;

— manatwork

ओउ मैं खाली टर्नरी के बारे में भूल गया। अच्छा निर्णय!

— सैमसक्च

Answer 22

MATL , 10 बाइट्स

q`QtVda}G-

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

यह इनपुट को बढ़ाता रहता है जब तक कि सभी अंक समान न हों, इसलिए यह धीमा है। 87654321ऑनलाइन संकलक में इनपुट समय के लिए परीक्षण का मामला ।

q      % Take input implicitly. Subtract 1
`      % Do...while loop
  Q    %   Increment top of the stack
  tV   %   Duplicate and convert to string (i.e. digits of the number)
  d    %   Difference between consecutive digits
  a    %   True if any such difference is nonzero. This is the loop condition
}      % Finally (execute on loop exit)
  G-   %   Subtract input. This is the final result, to be (implicitly) displayed
       % End loop implicitly. If loop condition (top of the stack) is truthy: proceeds 
       % with next iteration. Else: executes the "finally" block and exits loop
       % Display implicitly

Answer 23

रूबी, 42 अक्षर

->n{i=0;n.next!&&i+=1while n.squeeze[1];i}

स्ट्रिंग इनपुट की उम्मीद है।

नमूना रन:

irb(main):019:0> ->n{i=0;n.next!&&i+=1while n.squeeze[1];i}['87654321']
=> 1234567

रूबी, 39 अक्षर

पुनरावर्ती कॉल, बड़े परिणामों पर "SystemStackError: stack स्तर बहुत गहरा" में चलता है।

r=->n,i=0{n.squeeze[1]?r[n.next,i+1]:i}

नमूना रन:

irb(main):001:0> r=->n,i=0{n.squeeze[1]?r[n.next,i+1]:i}
=> #<Proc:0x00000002367ca0@(irb):10 (lambda)>

irb(main):002:0> r['20000']
=> 2222

Answer 24

मतलाब, 65 64 बाइट्स

t=input('');i=0;while nnz(diff(+num2str(t+i)))
i=i+1;end
disp(i)

जबकि पाश की वजह से यह धीमी है ...

व्याख्या

t=input('')  -- takes input
i=0          -- set counter to 0
while 
          num2str(t+i)   -- convert number to string 
         +               -- and then to array of corresponding ASCII codes
    diff(             )  -- produce vector of differences (all zeros for 'repdigit')
nnz(                   ) -- and count non-zero entries
i=i+1                    -- while not all digits are the same increase the counter
end          -- end while loop
disp(i)      -- print the counter

@Luis मेंडू के लिए धन्यवाद एक बाइट की बचत ।

Comments

Do you really need that +0? diff automatically casts chars to numbers

— Luis Mendo

In my version if I dont't add it, diff treats the string as sym and tries to differentiate.

— pajonk

Then maybe move the plus to the front (as a unary operator) and remove the zero

— Luis Mendo

Answer 25

Excel, 85 79 bytes

Put the following formula in any cell except cell N since it's a name for reference cell of input:

=IF(1*(REPT(LEFT(N),LEN(N)))<N,REPT(LEFT(N)+1,LEN(N))-N,REPT(LEFT(N),LEN(N))-N)

Explanation:

• N is the input and also name of reference cell.
• LEFT(N) take the first digit of input value.
• LEN(N) return the length of input value.
• REPT(LEFT(N),LEN(N)) repeat the first digit of input value LEN(N) times and multiply it by 1 to convert text format to number format so we can use it for number comparison.
• The syntax for the IF function in Microsoft Excel is: IF( condition, [value_if_true], [value_if_false]), hence makes the whole formula is self-explanatory.

Comments

You can omit Num_chars in LEFT and save 4 bytes: LEFT(N)

— Wernisch

Make that 6 bytes

— Wernisch

@Wernisch Thanks. Edited.

— Anastasiya-Romanova 秀

You can save 25 bytes by coercing the IF condition into a 1 or 0 using -- thus you do not need to repeat yourself just to +1: =REPT(LEFT(N)+(--1*(REPT(LEFT(N),LEN(N)))<N),LEN(N))-N

— i_saw_drones

Actually, in this instance, you don't need to coerce it explicitly, you can instead just use: =REPT(LEFT(N)+(1*(REPT(LEFT(N),LEN(N)))<N),LEN(N))-N, saving 27 bytes to give a total of 52.

— i_saw_drones

Answer 26

Brachylog v2, 6 bytes

;.+=∧ℕ

Try it online!

  +       The sum of
          the input
;         and
 .        the output
   =      is a repdigit,
    ∧     and
          the output
     ℕ    is a whole number.

The 5-byte +↙.=∧ gets away with omitting ℕ because it doesn't try non-positive outputs at all, but it also fails when given a number which is already a repdigit because it doesn't try non-positive outputs at all.

Answer 27

Java, 59 bytes

int c(int i){return(i+"").matches("^(.)\\1*$")?0:c(i+1)+1;}

(I'm still not sure how to count Java entries, but according to the standard set by the first Java entry, this entry is 59 bytes, since it's 17 bytes shorter).

Anyway, if we have a repdigit, return 0, else add 1 to the input, call itself and add 1 to the result.

---

Ungolfed & test cases:

Try it here.

class Main{
  static int c(int i) {
    return
      (i+"").matches("^(.)\\1*$")
      ? 0
      : c(i+1) + 1;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(19122));
    // Entry below will run out of memory
    System.out.println(c(19121));
  }
}

Output:

Runtime error   time: 0.09 memory: 321152 signal:-1
0
11
109
2
2222
3100

As you can see, the last entry runs out of memory before it can finish. The (very appropriate) StackOverflowError is thrown from java.util.regex.Pattern.sequence(Pattern.java:2134), but I'm pretty confident there's nothing wrong with the regex itself, since it's the same one I used in my previous entry.

Answer 28

C#, 82 bytes

using System.Linq;n=>{int i=n;while((i+"").Distinct().Count()!=1)++i;return i-n;};

Answer 29

C, 84 bytes

d,n,l,f;F(i){for(n=0;1;){l=i+n++;d=l%10;f=0;while(l/=10)f|=l%10-d;if(!f)return--n;}}

Test main:

int main() {
  printf("%d\n", F(8));
  printf("%d\n", F(100));
  printf("%d\n", F(113));
  printf("%d\n", F(87654321));
  printf("%d\n", F(47));
  printf("%d\n", F(20000));
  printf("%d\n", F(11132));
}

Answer 30

Prolog, 120 bytes

r([H|T]):-r(H,[H|T]).
r(H,[H|T]):-r(H,T).
r(_,[]).
g(N,0):-number_chars(N,L),r(L).
g(N,X):-N1 is N+1,g(N1,X1),X is X1+1.

Try it online!