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

आपका कार्य, यदि आप इसे स्वीकार करना चाहते हैं, तो एक प्रोग्राम लिखना है जो पोस्ट आईडी को इनपुट के रूप में लेता है (मानक पूर्णांक, आप 2 ^ 32 से नीचे मान सकते हैं), और अंत में कितने दोहराए गए अंक लौटाते हैं।

नियम

मानक खामियों को अस्वीकार कर दिया जाता है ।
कार्यक्रम एक फ़ंक्शन, पूर्ण प्रोग्राम, REPL कमांड हो सकता है, जो कुछ भी काम करता है, वास्तव में, जब तक कि इसे चलाने के लिए कोई बाहरी बेशुमार कोड / तर्क की आवश्यकता न हो।
इनपुट STDIN, फ़ंक्शन आर्गुमेंट्स, कमांड लाइन तर्क, फ़ाइल, जो भी आपको सूट करता है, से आ सकता है।

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

Input: 14892093
Output: 1

Input: 12344444
Output: 5

Input: 112311
Output: 2

Input: 888888
Output: 6

Input: 135866667 //Post number I got on /pol/ few days ago, rip
Output: 1

— sagiksp
स्रोत

1

क्या हमें स्ट्रिंग के रूप में इनपुट लेने की अनुमति है?

— मृत पोसम

6

@DeadPossum मुझे लगता है कि अनुमति है, क्योंकि आप वैसे भी एक स्ट्रिंग मिलता है अगर आप STDIN, कमांड लाइन तर्क या फ़ाइल (जो सभी स्वीकार्य इनपुट विधि हैं) से इनपुट पढ़ते हैं।

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

1

क्या हम मान सकते हैं कि इनपुट 0 से अधिक होगा?

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

1

@ मर्टिनएंडर यस

— sagiksp

2

शावक खेल के लिए अपवोट! Check'em!

— ज़ोंबीक्राउड

19

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

कैसे एक अंकगणितीय समाधान के बारे में?

IntegerExponent[9#+#~Mod~10]&

मुझे यह देखकर बहुत खुशी हो रही है कि यह सीधे-सीधे मैथमेटिका दृष्टिकोण को मात देता है।

व्याख्या

कोड में ही गणना करता है 9 * n + n% 10 और उसके बाद के सबसे बड़े बिजली पाता है 10 कि विभाजित इनपुट, या दूसरे शब्दों में, अनुगामी शून्य गिना जाता है। हमें यह दिखाने की जरूरत है कि क्या n k के दोहराया अंकों में समाप्त होता है , कि 9 * n + n% 10 में k है शून्य है।

9 से 99999 (जो कि 10 ⁵ -1 ) जैसी संख्या को विभाजित करके और फिर दोहराया अंक से गुणा करके, री-डिजिट को सबसे आसानी से गणितीय रूप से व्यक्त किया जाता है । इसलिए हम यह सुनिश्चित करने के लिए n = m * 10 ^k + d * (10 ^k -1) / 9 , जहाँ m (d (mod 10) लिख सकते हैं , यह सुनिश्चित करने के लिए कि n बार-बार k अंकों से अधिक में समाप्त नहीं होता है । ध्यान दें कि d = n% 10 ।

चलो कि हमारे सूत्र 9 * n + n% 10 में प्लग करें । हमें 9 * m * 10 ^k + d * (10 ^k -1) + d मिलता है । घ अंत में रद्द कर दिया है, इसलिए हम साथ छोड़ रहे हैं: 9 * मी * 10 ^k + d * 10 ^{कश्मीर} = (9 * मीटर + घ) * 10 ^{कश्मीर} । लेकिन 9 m -1 (मॉड 10) , इसलिए 9 * एम + डी m डी - एम (मॉड 10) । लेकिन हमने कहा है कि m that d (mod 10) और इसलिए d - m mod 0 (mod 10) ।

दूसरे शब्दों में, हम से पता चला है कि 9 * मीटर + d से विभाज्य नहीं है 10 और इसलिए, सबसे बड़ी शक्ति 10 कि विभाजित 9 * n + n% 10 = (9 * मीटर + घ) * 10 ^{कश्मीर} है कश्मीर , बार-बार आने वाले अंकों की संख्या।

एक बोनस के रूप में, यह समाधान ∞इनपुट के लिए , सही परिणाम प्रिंट करता है 0।

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

1

यह इस तरह से है कि मैं इस साइट का समर्थन करता हूं MathJax; बोल्ड फॉर्मूले टाइपसेट वालों की तरह अच्छे नहीं हैं। यह अच्छा है कि आपने समय-समय पर प्रतिपादक सुपरस्क्रिप्ट लिखने के लिए समय लिया।

— wizzwizz4

1

@ wizzwizz4 मैं कोड स्वरूपण का उपयोग करता था, लेकिन मैंने पाया है कि बोल्ड (जो आमतौर पर डेनिस द्वारा उपयोग किया जाता है) उससे थोड़ा अधिक पठनीय है। लेकिन सहमत, यह MathJax जितना अच्छा नहीं है।

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

13

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

&`(.)\1*$

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

ओवरलैपिंग मैचों की संख्या की गणना करता है, (.)\1*$जो एक रेक्सक्स है जो समान वर्णों के प्रत्यय से मेल खाता है।

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

2

यह एक मेम होना चाहिए: आप और आपका रेगेक्स

— क्रिस्टोफर

मुझे इन सभी संशोधकों को सीखने की आवश्यकता है - मैं बस के लिए चला गया होगा (.)(?=\1*$)।

— नील

1

@DownChristopher उन्होंने सचमुच रीगेक्स -आधारित भाषा बनाई, यह मेमे मटीरियल से परे जाती है c:

— Rod

1

@ नील अगर यह किसी भी सांत्वना है, तो मेरा पहला प्रयास था (?=(.)\1*$)(इसलिए मूल रूप से आपके समान ही)।

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

1

हां धन्यवाद!

— नील

9

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

ẹḅtl

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

व्याख्या

ẹ       Elements: split to a list of digits
 ḅ      Blocks: group consecutive equal digits into lists
  t     Tail: take the last list
   l    Length: Output is the length of that last list

यदि ḅसीधे पूर्णांक पर काम किया जाता है (और मुझे यकीन नहीं है कि मैंने इसे लागू क्यों नहीं किया ताकि यह ऐसा हो), यह केवल 3 बाइट्स ẹहोगा क्योंकि इसकी आवश्यकता नहीं होगी।

— Fatalize
स्रोत

9

अजगर 2 , 47 41 बाइट्स

lambda s:len(`s`)-len(`s`.rstrip(`s%10`))

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

36 बाइट्स - अधिक लचीले इनपुट के लिए

lambda s:len(s)-len(s.rstrip(s[-1]))

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

— छड़ी
स्रोत

वाह। मैं बिल्डरों को और अधिक ध्यान से सीखता हूं। +1

— मृत पोसुम

2

@DeadPossum dir(object)हमारा मित्र है c:

— Rod

BTW हमें इनपुट के रूप में स्ट्रिंग लेने की अनुमति नहीं है। "यदि आपके इनपुट की विधि स्वचालित रूप से स्ट्रिंग लौटाती है, तो निश्चित है, लेकिन आप यह नहीं मान सकते हैं कि इनपुट स्ट्रिंग्स के रूप में प्रदान किया जाएगा।" : सी

— डेड पोसम

1

@DeadPossum मुझे लगता है कि लेखक ने उस बारे में अपना विचार बदल दिया। लगता है कि टिप्पणी हटा दी गई है।

— ब्रायन मैककिनटन ने

8

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

a=>a.match`(.)\\1*$`[0].length

सहेजी गयी 19 regex की जगह @MartinEnder करने के लिए धन्यवाद बाइट्स
सहेजे गए 2 बाइट्स टैग किए गए टेम्प्लेट शाब्दिकों का उपयोग करके @ user81655 के लिए धन्यवाद

अंतिम अंक के अंतिम समूह के मिलान के लिए एक रेगेक्स का उपयोग करना

नोट: पहली बार पोस्टिंग टिप्पणी करने में संकोच न करें।

f=a=>a.match`(.)\\1*$`[0].length


console.log(f("14892093"));//1
console.log(f("12344444"));//5
console.log(f("112311"));//2
console.log(f("888888"));//6
console.log(f("135866667 "));//1

— Weedoze
स्रोत

PPCG में आपका स्वागत है! आप मैन्युअल रूप से दोहराए गए चरित्र को भरने के बजाय एक बैकरेस्ट का उपयोग करके बहुत सारे बाइट्स बचा सकते हैं:/(.)\1*$/

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

इसके अलावा, अनाम कार्य पूरी तरह से ठीक हैं (जब तक कि आपको उदाहरण के लिए पुनरावर्ती कॉल के लिए नाम की आवश्यकता न हो), तो आप दो बाइट्स को बचा सकते हैं f=।

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

बहुत बढ़िया! यह निश्चित रूप से समीक्षा के लिए गुजरता है लेकिन यह गोल्फ हो सकता है

— क्रिस्टोफर

@MartinEnder धन्यवाद! मुझे अभी भी सीखना है कि कैसे गोल्फ

— वेदेज़

@DownChristopher धन्यवाद! मैं अगली बार बेहतर करने की कोशिश

— करूंगा

7

C, 62 56 48 47 बाइट्स

@Steadybox के लिए एक बाइट धन्यवाद बचा लिया!

j,k;f(n){for(k=j=n%10;j==n%10;n/=10,k++);k-=j;}

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

— betseg
स्रोत

7

PHP, 47 45 40 बाइट्स

while($argn[-++$i]==$argn[-1]);echo$i-1;

साथ दौड़ो echo <n> | php -nR '<code>

लगता है कि एक लूप अभी भी मेरे पहले उत्तर से छोटा है। बस उन वर्णों को गिनें जो अंतिम के बराबर हैं। यह PHP 7.1 के नकारात्मक स्ट्रिंग ऑफसेट का उपयोग करता है ।

टाइटस द्वारा -5 बाइट्स । धन्यवाद !

पुराना उत्तर:

<?=strlen($a=$argv[1])-strlen(chop($a,$a[-1]));

सही चरित्र से मेल खाते हर पात्र को हटाता है और लंबाई में अंतर की गणना करता है।

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

-Rऔर $argn5 बाइट्स बचा सकता है।

— टाइटस

6

05AB1E , 4 बाइट्स

.¡¤g

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

व्याख्या

.¡    # group consecutive equal elements in input
  ¤   # get the last group
   g  # push its length

— Emigna
स्रोत

6

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

re`W=0=

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

व्याख्या

r   e# Read input.
e`  e# Run-length encode.
W=  e# Get last run.
0=  e# Get length.

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

6

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

DŒgṪL

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

व्याख्या

D      # convert from integer to decimal   
 Œg    # group runs of equal elements
   Ṫ   # tail
    L  # length

— Emigna
स्रोत

6

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

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

/(.)\1*$/;$_=length$&

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

/(.)\1*$/अंतिम समान संख्याएं प्राप्त करता है, और फिर $_=length$&इसकी लंबाई को निर्दिष्ट करता है $_, जो कि -pफ्लैग करने के लिए अंतर्निहित रूप से मुद्रित है ।

— बापू
स्रोत

6

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

f(x){x=x%100%11?1:-~f(x/10);}

यह मेरे पायथन उत्तर का एक बंदरगाह है ।

जीसीसी के साथ यह काम करता है, लेकिन एक returnबयान की कमी अपरिभाषित व्यवहार है।

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

— डेनिस
स्रोत

मैं असमंजस में हूं, आप कैसे न तो पॉइंटर पास करते हैं, और स्थान पर मूल्य बदलते हैं, या केवल मान लौटाते हैं। ऐसा लगता है कि यह केवल स्थानीय प्रतिलिपि को बदलता है, जो फ़ंक्शन को अनुपयोगी बना देगा, लेकिन यह TIO पर काम करता है। आप पाद में 1 से n भी जोड़ते हैं, बल्कि उसके बाद sizeof (int), जो इसे 1 बाइट को आगे नहीं बढ़ाएगा, बजाय एक इंट की पूरी चौड़ाई के? स्पष्ट रूप से कुछ तरकीबें हैं जो मैं यहां सीख सकता था, और मैं शायद अपने उत्तर में पहले का उपयोग कर सकता था।

— बिजन

2

सभी returnविवरण ईएएक्स में रिटर्न वैल्यू को स्टोर कर रहा है। Gcc के साथ, इसे एक वैरिएबल पर असाइन करना समान कार्य करने के लिए होता है। सूचक अंकगणितीय के लिए, जब आप एक int सूचक में 1 जोड़ते हैं, तो यह अगले बाइट में नहीं, अगले int पर जाता है।

— डेनिस

क्या ऐसे मामले हैं (जब ints का उपयोग करना) जब वापस लौटना बेहतर होगा, तो ऐसा लगता है कि सबसे खराब स्थिति में आप एक नया इंट बनाएंगे, और उसे असाइन करेंगे।

— बिजन

@ बीजन सी कंपाइलर्स हमेशा प्रश्न में आदिम के एक परमाणु के आकार के लिए प्रत्यक्ष मेमोरी एक्सेस को संरेखित करते हैं - मुझे याद नहीं है कि यह मानक में है, हालांकि

— बिल्ली

5

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

पूर्णांक को इनपुट के रूप में लेता है। इसे ऑनलाइन आज़माएं

lambda S:[x==`S`[-1]for x in`S`[::-1]+'~'].index(0)

इनपुट के रूप में स्ट्रिंग के लिए 48 बाइट्स। इसे ऑनलाइन आज़माएं

lambda S:[x==S[-1]for x in S[::-1]+'~'].index(0)

— मृत पोसुम
स्रोत

5

सी # , 63 62 बाइट्स

golfed

i=>{int a=i.Length-1,b=a;while(a-->0&&i[a]==i[b]);return b-a;}

Ungolfed

i => {
    int a = i.Length - 1,
        b = a;

    while( a-- > 0 && i[ a ] == i[ b ] );

    return b - a;
}

अनपढ़ पठनीय

i => {
    int a = i.Length - 1, // Store the length of the input
        b = a ;           // Get the position of the last char

    // Cycle through the string from the right to the left
    //   while the current char is equal to the last char
    while( a-- > 0 && i[ a ] == i[ b ] );

    // Return the difference between the last position
    //   and the last occurrence of the same char
    return b - a;
}

पूर्ण कोड

using System;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, Int32> f = i => {
            int a = i.Length - 1, b = a;
            while( a-- > 0 && i[ a ] == i[ b ] );
            return b - a;
         };

         List<String>
            testCases = new List<String>() {
               "14892093",
               "12344444",
               "112311",
               "888888",
               "135866667"
            };

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

         Console.ReadLine();
      }
   }
}

विज्ञप्ति

v1.1 - - 1 byte - केविन की टिप्पणी के लिए धन्यवाद ।
v1.0 - 63 bytes- प्रारंभिक समाधान।

टिप्पणियाँ

कुछ भी जोड़ने के लिए नहीं है

— auhmaan
स्रोत

+1 हालांकि आप इसे 1 बाइट के साथ गोल्फ कर सकते हैं। इस तरह:i=>{int a=i.Length-1,b=a;while(a-->0&&i[a]==i[b]);return b-a;}

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

5

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

f=lambda n:0<n%100%11or-~f(n/10)

6 बाइट बचाने के लिए @xnor को धन्यवाद!

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

— डेनिस
स्रोत

4

MATL , 6 5 बाइट्स

1 बाईट ने @Luis को धन्यवाद दिया

&Y'O)

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

व्याख्या

        % Implicitly grab input as a string
&Y'     % Perform run-length encoding on the string but keep only the second output
        % Which is the number of successive times an element appeared
O)      % Grab the last element from this array
        % Implicitly display

— Suever
स्रोत

मैं भूल गया था कि &ऐसा किया था Y': -D क्यों नहीं इनपुट के रूप में एक स्ट्रिंग उद्धरण में संलग्न और छुटकारा पाने के लिए j?

— लुइस मेन्डो

@LuisMendo मुझे यकीन नहीं था कि मैं ऐसा कर सकता हूं क्योंकि चुनौती ने स्पष्ट रूप से कहा था कि इनपुट एक "पूर्णांक" था

— स्वेरा

मैंने मार्टिन की टिप्पणी और डिफ़ॉल्ट नियमों से ऐसा मान लिया , जो इसकी अनुमति देते हैं। लेकिन मुझे सच में यकीन नहीं है

— लुइस मेंडो

@LuisMendo आह ओके ने उनकी टिप्पणी नहीं देखी। अपडेट करूंगी!

— सूपर

4

क्यूबिक्स, 24 19 बाइट्स

)uO)ABq-!wpUp)W.@;;

ध्यान दें

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

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

व्याख्या

सबसे पहले, आइए घन का विस्तार करें

    ) u
    O )
A B q - ! w p U
p ) W . @ ; ; .
    . .
    . .

निष्पादन के चरणों को तीन चरणों में विभाजित किया जा सकता है:

पार्स इनपुट
पात्रों की तुलना करें
प्रिंट परिणाम

चरण 1: इनपुट

निष्पादित होने वाले पहले दो वर्ण हैं Aऔर B।Aसभी इनपुट को पढ़ता है और इसे स्टैक के चरित्र कोड के रूप में धकेलता है। ध्यान दें कि यह रिवर्स में किया जाता है, पहला चरित्र ढेर के ऊपर समाप्त होता है, अंतिम चरित्र लगभग नीचे। बहुत नीचे, -1( EOF) रखा गया है, जो स्ट्रिंग के अंत में लगातार पात्रों की मात्रा के लिए एक काउंटर के रूप में उपयोग किया जाएगा। चूँकि हमें पिछले दो पात्रों को शामिल करने के लिए स्टैक के शीर्ष की आवश्यकता है, हम लूप में प्रवेश करने से पहले स्टैक को उल्टा करते हैं। ध्यान दें कि स्टैक का शीर्ष भाग अब जैसा दिखता है:..., C[n-1], C[n], -1 :।

क्यूब पर आईपी का स्थान वह जगह है जहां E है, यह सही इंगित करता है। सभी निर्देश जो अभी तक निष्पादित नहीं किए गए हैं, उन्हें नो-ऑप्स (पूर्ण स्टॉप) द्वारा बदल दिया गया था।

    . .
    . .
A B E . . . . .
. . . . . . . .
    . .
    . .

चरण 2: चरित्र की तुलना

स्टैक है ..., C[a-1], C[a], counter, जहांcounter दो वर्णों की जांच ( C[a]और C[a-1]) के बराबर होने पर वेतन वृद्धि का काउंटर है । IP सबसे पहले इस लूप को Sचरित्र में प्रवेश करता है , दाएं घूमते हुए। Eचरित्र स्थान है जहाँ आईपी खत्म हो जाएगा (सही इशारा करते हुए) जब है C[a]और C[a-1]एक ही मूल्य है, जो मतलब है कि घटाकर की जरूरत नहीं है C[a]से C[a-1]उपज नहीं है 0, जिस स्थिति अनुदेश निम्नलिखित में !छोड़ दिया जाएगा (जो एक है w)।

    . .
    . .
. S q - ! w E .
p ) W . . ; ; .
    . .
    . .

यहां वे निर्देश दिए गए हैं जो एक पूर्ण लूप के दौरान निष्पादित किए जाते हैं:

q-!;;p) # Explanation
q       # Push counter to the bottom of the stack
        #     Stack (counter, ..., C[a-1], C[a])
 -      # Subtract C[a] from C[a-1], which is 0 if both are equal
        #     Stack (counter, ..., C[a-1], C[a], C[a-1]-C[a])
  !     # Leave the loop if C[a-1]-C[a] does not equal 0
   ;;   # Remove result of subtraction and C[a] from stack
        #     Stack (counter, ..., C[a-1])
     p  # Move the bottom of the stack to the top
        #     Stack (..., C[a-1], counter)
      ) # Increment the counter
        #     Stack (..., C[a-1], counter + 1)

और फिर यह चारों ओर घूमता है।

चरण 3: प्रिंट परिणाम

चूंकि हमने लूप को जल्दी छोड़ दिया था, स्टैक इस तरह दिखता है counter, ..., C[a-1]-C[a]:। काउंटर को प्रिंट करना आसान है, लेकिन हमें एक बार काउंटर को बढ़ाना होगा क्योंकि हमने इसे लूप के अंतिम पुनरावृत्ति में नहीं किया था, और एक बार और क्योंकि हमने -1इसके बजाय गिनती शुरू की 0। क्यूब पर रास्ता इस तरह दिखता है, शुरू होता है S, सही इंगित करता है। आईपी द्वारा निष्पादित दो नो-ऑप्स को तीर द्वारा प्रतिस्थापित किया जाता है जो आईपी की दिशा में इंगित करते हैं।

    ) u
    O )
. B . . . S p U
. ) . . @ . . .
    > >
    . .

निर्देशों को निम्नलिखित क्रम में निष्पादित किया जाता है। ध्यान दें कि B)अंत में निर्देश स्टैक को बदलते हैं, लेकिन प्रोग्राम को प्रभावित नहीं करते हैं, क्योंकि हम इसे समाप्त करने वाले हैं, और हम स्टैक का उपयोग नहीं करते हैं।

p))OB)@ # Explanation
p       # Pull the counter to the top
        #     Stack: (..., counter)
 ))     # Add two
        #     Stack: (..., counter + 2)
   O    # Output as number
    B)  # Reverse the stack and increment the top
      @ # End the program

एलिया इक्टाका स्था।

— ल्यूक
स्रोत

3

बैच, 91 बाइट्स

@set s=-%1
@set n=1
:l
@if %s:~-2,1%==%s:~-1% set s=%s:~,-1%&set/an+=1&goto l
@echo %n%

-रोकता है स्ट्रिंग के शुरू होने से बंद चलने से परीक्षण।

— नील
स्रोत

3

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

f=(n,p)=>n%10-p?0:1+f(n/10|0,n%10)

रेगेक्स समाधान से कम नहीं।

पुनरावर्ती कार्य जो एक अलग अंक का सामना करने पर रोकते हुए अंकों को दाएं-बाएं से मूल्यांकन करता है। परिणाम पुनरावृत्तियों की संख्या है। pहै undefinedपहली यात्रा है, जिसका अर्थ पर n%10-pरिटर्न NaN(falsy)। उसके बाद, pपिछले अंक के साथ बराबर होता है n%10। जब वर्तमान अंक ( n%10) और पिछले ( p) अलग होते हैं, तो लूप समाप्त होता है।

— user81655
स्रोत

3

रोड़ा , 12 बाइट्स

{count|tail}

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

यह एक अनाम फ़ंक्शन है जो उम्मीद करता है कि इनपुट स्ट्रिंग के प्रत्येक चरित्र को स्ट्रीम में धकेल दिया जाएगा (मुझे लगता है कि यह आत्मा की भावना में मान्य है हालिया मेटा प्रश्न )।

यह दो बिल्डरों का उपयोग करता है: countऔर tail:

count स्ट्रीम से मान पढ़ता है और स्ट्रीम में लगातार तत्वों की संख्या को धक्का देता है।
tail स्ट्रीम में अंतिम मान लौटाता है।

— fergusq
स्रोत

3

टी-एसक्यूएल, 238 214 बाइट्स

declare @ varchar(max) = '' declare @i int=0, @e int=0, @n int=right(@,1), @m int while (@i<=len(@)) begin set @m=(substring(@,len(@)-@i,1)) if (@n=@m) set @e=@e+1 else if (@i=0) set @e=1 set @i=@i+1 end select @e

या:

declare @ varchar(max) = '12345678999999'
declare 
    @i int = 0,
    @e int = 0,
    @n int = right(@,1),
    @m int

while (@i <= len(@))
begin
    set @m = (substring(@,len(@)-@i,1))
    if (@n = @m) set @e = @e + 1
    else
    if (@i) = 0 set @e = 1
    set @i = @i + 1
end
select @e

— Nelz
स्रोत

2

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

int c(int n){return(""+n).length()-(""+n).replaceAll("(.)\\1*$","").length();}

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

मैंने कुछ चीजों की पुनरावृत्ति या एक लूप का उपयोग करने की कोशिश की, लेकिन दोनों 100 बाइट्स से ऊपर समाप्त हो गए।

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

2

पॉवरशेल, 41 बाइट्स

for($n="$args";$n[-1]-eq$n[-++$a]){};$a-1

सीधा लूप पीछे की तरफ जब तक एक तार स्ट्रिंग में अंतिम चार से मेल नहीं खाता है, उस चार के सूचकांक को वापस करें।

-3 @AdmBorkBork के लिए धन्यवाद - थोड़ी देर के बजाय लूप के लिए उपयोग करना।

— colsw
स्रोत

2

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

3 बाइट्स बचाने के लिए ग्रेग मार्टिन को धन्यवाद।

Tr[1^Last@Split@Characters@#]&

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

दशमलव अंकों को प्राप्त करता है (वर्णों के रूप में), उन्हें समान तत्वों के रनों में विभाजित करता है, अंतिम रन प्राप्त करता है और वेक्टर की राशि लेने के मानक चाल के साथ लंबाई की गणना करता है 1^list।

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

Charactersके बजाय IntegerDigits?

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

@GregMartin आह हाँ, मुझे लगता है। धन्यवाद।

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

आप अभी भी इस सवाल के लिए अन्य चतुर गणितज्ञ गोल्फर को नहीं हराते हैं ;)

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

@GregMartin क्या शर्म की बात है। :)

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

2

बैश + यूनिक्स उपयोगिताओं, 34 बाइट्स

sed s/.*[^${1: -1}].//<<<x$1|wc -c

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

— मिशेल स्पेक्टर
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 39 38 37 27 बाइट्स

f=n=>n%100%11?1:1+f(n/10|0)

शायद रेगेक्स-आधारित समाधान से छोटा नहीं है, लेकिन मैं पूरी तरह से अंकगणित पर आधारित समाधान लिखने का विरोध नहीं कर सकता। तकनीक को n % 100 % 1110 तक बार-बार लेना और विभाजित करना है जब तक कि परिणाम शून्य न हो, तब पुनरावृत्तियों की गणना करें। यह काम करता है क्योंकि यदि अंतिम दो अंक समान हैं, तो n % 100 % 11होगा 0।

— ETHproductions
स्रोत

बेनाम: आह, तुम मुझे haha से पहले समाप्त हो गया! मुझे यकीन नहीं है कि एक और उत्तर पोस्ट करना है, क्योंकि वे सबसे अधिक संभावना गोल्फिंग के बाद अभिसरण करेंगे, लेकिन यहां 34 बाइट का उपयोग करके मेरा समाधान है:f=(n,p)=>n%10-p?0:1+f(n/10|0,n%10)

— user81655

@ user81655 यह बहुत अच्छा है, इसे पोस्ट करने के लिए स्वतंत्र महसूस करें। मुझे नहीं लगता कि मेरा पूरी तरह से बदलाव के बिना है कि करने के लिए नीचे अभिसरण जाएगा, और निश्चित रूप अब है कि मैं तुम्हारा कि नहीं होगा ;-) देखा है की

— ETHproductions

2

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

f(h:t)=sum[1|all(==h)t]+f t
f _=0

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

स्ट्रिंग इनपुट लेता है। बार-बार पहला पात्र काट देता है, और 1 जोड़ता है यदि प्रत्यय के सभी वर्ण पहले वाले के बराबर हैं।

— XNOR
स्रोत

2

आर, 35 बाइट्स

rle(rev(charToRaw(scan(,''))))$l[1]

संक्षिप्त विवरण

                  scan(,'')         # get input as a string
        charToRaw(         )        # convert to a vector of raws (splits the string)
    rev(                    )       # reverse the vector
rle(                         )$l[1] # the first length from run length encoding

— MickyT
स्रोत

2

Befunge-98 , 19 बाइट्स

01g3j@.$~:01p-!j$1+

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

यह कम किया जा सकता है अगर मैं केवल स्टैक का उपयोग करने में कामयाब रहा।

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

01g3j@.$~:01p-!j$1+
01g                 ; Get the stored value (default: 32)                 ;
   3j               ; Skip to the ~                                      ;
        ~           ; Get the next character of input                    ;
         :01p       ; Overwrite the stored value with the new char       ;
             -!     ; Compare the old value and the new                  ;
               j$   ; Skip the $ when equal, else pop the counter        ;
                 1+ ; Increment the counter                              ;

; When the input runs out, ~ reflects the IP and we run: ;
   @.$
     $              ; Pop the extraneous value (the stored value) ;
   @.               ; Print the number and exit                   ;

— जस्टिन
स्रोत

2

अजगर 3 - 50 44 बाइट्स

पूर्ण कार्यक्रम (पायथन 3 में, input()एक स्ट्रिंग लौटाता है, कोई फर्क नहीं पड़ता इनपुट):

g=input();print(len(g)-len(g.rstrip(g[-1])))

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

एक साथ अपने डब जाओ

नियम

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

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

व्याख्या

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

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

व्याख्या

अजगर 2 , 47 41 बाइट्स

36 बाइट्स - अधिक लचीले इनपुट के लिए

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

C, 62 56 48 47 बाइट्स

PHP, 47 45 40 बाइट्स

05AB1E , 4 बाइट्स

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

व्याख्या

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

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

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

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

सी # , 63 62 बाइट्स

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

MATL , 6 5 बाइट्स

क्यूबिक्स, 24 19 बाइट्स

ध्यान दें

व्याख्या

चरण 1: इनपुट

चरण 2: चरित्र की तुलना

चरण 3: प्रिंट परिणाम

बैच, 91 बाइट्स

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

रोड़ा , 12 बाइट्स

टी-एसक्यूएल, 238 214 बाइट्स

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

पॉवरशेल, 41 बाइट्स

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

बैश + यूनिक्स उपयोगिताओं, 34 बाइट्स

जावास्क्रिप्ट (ईएस 6), 39 38 37 27 बाइट्स

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

आर, 35 बाइट्स

Befunge-98 , 19 बाइट्स

अजगर 3 - 50 44 बाइट्स