ढहने की संख्या

Question

चलिए एक फ़ंक्शन को प्राकृतिक संख्या $n$ पर परिभाषित करते हैं , जिसे आधार 10 अंक d k के रूप में लिखा जाता है$d_k\; d_{k-1}\; \dotsc\; d_1\; d_0$ , निम्नानुसार है:

जब तक समीपवर्ती अंक , तब तक उन्हें उनके योग d i + d i - 1 से बाएं से दाएं बदलें । यदि ऐसे कोई अंक थे, तो उसी प्रक्रिया को दोहराएं।$d_i\;d_{i-1}$$d_i+d_{i-1}$

दूसरे शब्दों में, प्रत्येक पुनरावृत्ति में हम समान रूप से समीपवर्ती अंकों के सभी जोड़ों को लेते हैं और उन्हें उसी समय उनकी राशि से प्रतिस्थापित करते हैं (यदि वे ओवरलैप करते हैं तो बाएं-सबसे जोड़े का उपयोग करके)।

उदाहरण

उदाहरण के लिए $\texttt{9988}$ लेते हैं :

1. पहले समीपवर्ती अंक जो समान हैं दो $\texttt{9}$
2. इसलिए हम उन्हें $\texttt{9 + 9} = \texttt{18}$ बदल देते हैं जो हमें 1888 देता है$\texttt{1888}$
3. चूँकि हम अभी भी पहले बाएँ-दाएँ ट्रैवर्सल में हैं और अभी भी दो $\texttt{8}$ एस थे जिन्हें हमें पहले इनको बदलने की आवश्यकता थी
4. तो हमें $\texttt{1816}$
5. कुछ बदल गया है, इसलिए हमें एक और पुनरावृत्ति करने की आवश्यकता है
6. लेकिन ऐसे कोई अंक नहीं हैं, इसलिए हम रुक जाते हैं

इसलिए उस क्रम में $9988^\text{th}$ संख्या $1816$ ।

चुनौती

पहले 200 शब्द हैं:

0,1,2,3,4,5,6,7,8,9,10,2,12,13,14,15,16,17,18,19,20,21,4,23,24,25,26,27,28,29,30,31,32,6,34,35,36,37,38,39,40,41,42,43,8,45,46,47,48,49,50,51,52,53,54,10,56,57,58,59,60,61,62,63,64,65,12,67,68,69,70,71,72,73,74,75,76,14,78,79,80,81,82,83,84,85,86,87,16,89,90,91,92,93,94,95,96,97,98,18,10,101,102,103,104,105,106,107,108,109,20,21,4,23,24,25,26,27,28,29,120,121,14,123,124,125,126,127,128,129,130,131,132,16,134,135,136,137,138,139,140,141,142,143,18,145,146,147,148,149,150,151,152,153,154,20,156,157,158,159,160,161,162,163,164,165,4,167,168,169,170,171,172,173,174,175,176,24,178,179,180,181,182,183,184,185,186,187,26,189,190,191,192,193,194,195,196,197,198,28

आपका कार्य उस अनुक्रम को उत्पन्न करना है, या तो

• $n$ दिया गया है , उस क्रम में $n^\text{th}$ नंबर को वापस करें ,
• $n$ दिया गया है , उस क्रम में पहले $n$ संख्याएँ लौटाएँ
• या अनुक्रम अनिश्चित काल के लिए उत्पन्न करते हैं।

आप $0$ या - $1$ -exexing का उपयोग करने के लिए अपना सबमिशन चुन सकते हैं , लेकिन कृपया निर्दिष्ट करें कि कौन सा।

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

आप ऊपर दी गई शर्तों का उपयोग कर सकते हैं, हालाँकि यहाँ कुछ बड़े हैं:

222 -> 42
1633 -> 4
4488 -> 816
15519 -> 2019
19988 -> 2816
99999 -> 18189
119988 -> 21816
100001 -> 101
999999 -> 181818

Answer 1

पायथन 3 , 128 बाइट्स

def t(z):j=z and(z[0]==z[1:2])+1;return[str(int(z[0])*j),*t(z[j:])]if j else''
def c(n):r="".join(t(n));return r!=n and c(r)or r

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

Comments

PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!

— R

108 बाइट्स

— जो किंग

Answer 2

पायथन 2 , 97 96 93 बाइट्स

def f(n):r=re.sub(r'(.)\1',lambda m:`int(m.group(1))*2`,n);return r!=n and f(r)or r
import re

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

---

गैर रेगेक्स संस्करण:

पायथन 2 , 133 130 122 112 98 बाइट्स

def f(n):
 r='';s=n
 while s:a=1+(s[0]==s[1:2]);r+=`int(s[0])*a`;s=s[a:]
 return r!=n and f(r)or r

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

Answer 3

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

DŒg+2/€FVµ¡

यह एक अनावश्यक रूप से धीमा, पूर्ण कार्यक्रम है।

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

वैकल्पिक संस्करण, 12 बाइट्स

DŒg+2/€FVµƬṪ

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

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

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

DŒg+2/€FVµƬṪ  Main link. Argument: n (integer)

         µ    Combine the previous links into a chain. Begin a new one.
D               Decimal; yield n's digit array in base 10.
 Œg             Group adjacent, identical digits into subarrays.
   +2/€         Map non-overlapping, pairwise sum over the subarrays.
                If there is an odd number of digits in a subarray, the
                last digit will remain untouched.
       F        Flatten; dump all sums and digits into a single array.
        V       Eval; turn the result into an integer.
          Ƭ   Execute the chain 'til the results are no longer unique.
              Return all unique results.
           Ṫ  Tail; extract the last result.

11-बाइट संस्करण एक ही करता है, सिवाय इसके कि इनपुट n के लिए लिंक n बार कॉल करता है , बजाय एक निश्चित बिंदु तक पहुंचने तक इसे कॉल करने के लिए।

Comments

यह अनावश्यक नहीं है अगर यह 1 बाइट बचाता है :-)

— लुइस मेंडो

Answer 4

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

until((==)=<<f)f
f(a:b:c)|a==b=show(2*read[a])++f c|1<2=a:f(b:c)
f a=a

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

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

Comments

यह आपको अभी तक कुछ भी नहीं बचाता है, लेकिन एक ही लंबाई के साथ आप दूसरे खंड को प्रतिस्थापित कर सकते हैं |x<-b:c=a:f xया यहां तक ​​कि f(a:c)=a:f c, अगर एक या दूसरे को वास्तव में सुधार हो सकता है :)

— दोष

Answer 5

जावास्क्रिप्ट, 48 47 46 बाइट्स

इनपुट और आउटपुट स्ट्रिंग्स के रूप में। nthअनुक्रम का शब्द देता है ।

f=s=>s-(s=s.replace(/(.)\1/g,x=>x/5.5))?f(s):s

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

• 1 बाइट ने अरनौल को धन्यवाद दिया
• 1 बाइट टीश के लिए धन्यवाद बचा लिया

Comments

x[0]*2->x/5.5

— tsh

धन्यवाद, @ सत्। नहीं सोचा होगा कि।

— झिग्गी

Answer 6

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

{($_,{S:g[(\d)$0]=2*$0}...*==*)[*-1]}

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

यह एक फ़ंक्शन है जो अनुक्रम के एनटी शब्द को उत्पन्न करता है, जिसे इसके तर्क के रूप में n दिया जाता है।

($_, { ... } ... * == *)क्रम संख्या में क्रमिक परिवर्तनों का क्रम है, जो ब्रैकेटेड एक्सप्रेशन (एक साधारण रेगेक्स प्रतिस्थापन) द्वारा उत्पन्न होता है और जब * == *क्रम में अंतिम दो संख्याएँ समान होती हैं, तब रुक जाती हैं। फिर [*-1]वापसी के मूल्य के रूप में उस अनुक्रम का अंतिम तत्व लेता है।

Comments

आप बाइट्स को हटा सकते हैं ==*और उनके *-1साथ बदल $_सकते हैं, क्योंकि nकिसी संख्या के लिए हमेशा प्रतिस्थापन से कम होते हैं n। 33 बाइट्स

— जो किंग

Answer 7

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

+`(.)\1
$.(2*$1*

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

+`

इनपुट बदलना बंद होने तक दोहराएं।

(.)\1

आसन्न अंकों के जोड़े बदलें ...

$.(2*$1*

... दो बार अंक के साथ। ( एस $1*का एक स्ट्रिंग उत्पन्न करता है $1 _, जो 2*डुप्लिकेट करता है, और $.(लंबाई लेता है। वास्तव में, रेटिना इंजन उससे अधिक चालाक है और बस दोगुना है $1।)

Answer 8

सी # (.NET कोर) , 231 , 203 , 200 , 196 , 192 बाइट्स

संपादित करें: फ़ंक्शन 185 बाइट्स प्लस 18 के लिए अब है using System.Linq;

BMO के लिए धन्यवाद (1> 0 सत्य प्लस न्यूलाइन हटाने के बराबर है) और मिस्टर एक्सकोडर (f! F स्टेटमेंट के लिए)!

EDIT2: डाउन टू 182 बाइट्स प्लस 18 फॉर using System.Linqदाना टू धन्यवाद कुछ गोल्फ टिप्स शेयर करने के लिए!

EDIT3: int [] -> var के लिए इग्नोरेंस के अवतार के लिए धन्यवाद, शॉर्ट सर्किट को हटाकर && -> &, और ToArray को बदलकर -> ToList! (178 बाइट्स + 18 का उपयोग करके)

EDIT4: अज्ञानता का अवतार एक असाइनमेंट को बदलकर 4 बाइट्स गिरा दिया। डमी मुझे चाहिए गिना! धन्यवाद फिर से: डी

p=>{var f=1>0;while(f){var t=p.Select(n=>n-48).ToList();p="";f=!f;for(var j=0;j<t.Count;j++){if(j<t.Count-1&t[j]==t[1+j]){p+=t[j]+t[++j];f=!f;continue;}p+=t[j];}};return p;};

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

Comments

उपयोग करने से पहले 174

— अज्ञानता

Answer 9

पर्ल 5 -p , 21 बाइट्स

s/(.)\1/$1*2/ge&&redo

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

Answer 10

जाप v2.0a0 -h, 15 14 बाइट्स

nthअनुक्रम का शब्द देता है ।

Æ=s_r/(.)\1/ÏÑ

कोशिश करो

यह 10 बाइट्स के लिए काम करना चाहिए लेकिन जाप के पुनरावर्ती प्रतिस्थापन विधि में एक बग प्रतीत होता है।

e/(.)\1/ÏÑ

Answer 11

ग्रूवी , 63 बाइट्स

{s->r=/(\d)\1/
while(s=~r)s=s.replaceAll(r){(it[1]as int)*2}
s}

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

Answer 12

05AB1E , 11 बाइट्स

Δγε2ôSO}˜J

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Δ             # Continue until the (implicit) input no longer changes:
 γ            #  Split the integer in chunks of the same adjacent digits
              #   i.e. 199999889 → [1,99999,88,9]
  ε     }     #  Map each to:
   2ô         #   Split it into parts of size 2
              #    i.e. 99999 → [99,99,9]
     €S       #   Split each part into digits
              #    i.e. [99,99,9] → [[9,9],[9,9],[9]]
       O      #   And take the sum of each part
              #    i.e. [[9,9],[9,9],[9]] → [18,18,9]
         ˜    #  Flatten the list
              #   i.e. [[1],[18,18,9],[16],[9]] → [1,18,18,9,16,9]
          J   #  Join everything together
              #   i.e. [1,18,18,9,16,9] → 118189169
              # (And output the result implicitly at the end)
              #  i.e. output = 28189169

Answer 13

वोल्फ्राम भाषा 108 बाइट्स

ToExpression[""<>ToString/@Total/@Flatten[Partition[#,UpTo@2]&/@Split@IntegerDigits@#,1]]&~FixedPoint~#&

व्याख्या

IntegerDigits इनपुट संख्या को उसके अंकों की सूची में बदल देता है।

Split लगातार दोहराए गए समूह।

Partition[#, UpTo@2]&/@ 2 की लंबाई पर, अंकों की सूची में अंकों के रन को तोड़ता है।

Flatten[...,1] ओवर-नेस्टेड ब्रेसेस को कभी-कभी समाप्त कर देता है - उदाहरण के लिए, {{2,2}} {2,2} बन जाता है

Total/@योग युग्मित अंकों के योग। पृथक अंकों को सारांशित करने की आवश्यकता नहीं है।

ToString योग (और पृथक अंक) को तार में परिवर्तित करता है।

""<> सूची में सभी तार जुड़ते हैं।

ToExpression परिणाम को पूर्णांक में परिवर्तित करता है।

...~FixedPoint~#& फ़ंक्शन तब तक लागू होता है जब तक कि परिणाम बदलना बंद न हो जाए।

Answer 14

फ्लैग के साथ सी # (विजुअल सी # इंटरएक्टिव कंपाइलर)/u:System.Text.RegularExpressions.Regex , 70 बाइट्स

s=>{for(;s[0]!=(s[0]=Replace(s[0],@"(.)\1",m=>m.Value[0]*2-96+"")););}

इनपुट को संशोधित करके आउटपुट। एक सूची में इनपुट के लिए एक स्ट्रिंग लेता है।

एक पूरे 23 बाइट गोल्फिंग के लिए @ डाना को धन्यवाद!

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

Comments

95 + 34 - 33 + 1 अतिरिक्त स्थान के लिए जो आपको कमांडलाइन आर्ग्स में चाहिए, iirc

— केवल

पुनरावर्ती अनाम कार्यों को पहले परिभाषित किया जाना है, और परिभाषा बाइट गणना में शामिल है।

— अज्ञानता

ओह, यह पुनरावर्ती है

— एएससीआईआई-ओनली

अच्छा! मुझे लगता है कि मैं इसे थोड़ा और नीचे ले जा सकता हूं

— अज्ञानता का अवतार

यह एक बहुत अच्छा स्कोर है यह देखते हुए कि यह C # :)

— दाना

Answer 15

क्लीन , 118 बाइट्स

import StdEnv,Data.List
$[a,b:t]|a==b=[1,(a*2)rem 10]%(1-a/5,1)++ $t=[a: $[b:t]]
$l=l

limit o iterate$o map digitToInt

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

लेम्बडा limitके अनुप्रयोगों की अनंत सूची से पहला दोहराया मूल्य ( ) iterateढहने की प्रक्रिया के एकल चरण का प्रदर्शन करता है। इनपुट के रूप में लिया गया [Char]।

Answer 16

लाल , 84 83 80 बाइट्स

func[n][if parse s: form n[to some change[copy d skip d](2 * do d)to end][f s]s]

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

nthअनुक्रम का शब्द देता है ।

स्पष्टीकरण:

Red[]
f: func [ n ] [
    if parse s: form n [  ; parse the input converted to a string
        to some change [  ; find and change one or more
            copy d skip   ; digit (in fact any character, no predefined character classes)
            d             ; followed by itself
        ] (2 * do d)      ; with its doubled numeric value 
        to end            ; go to the end of the string
    ] [ f s ]             ; call the function with the altered string if parse returned true
    s                     ; finally return the string 
]

Answer 17

स्काला , 84 बाइट्स

s=>{var t=s
while(t!=(t="(\\d)\\1".r.replaceAllIn(t,m=>s"$m"(0)*2-96+""),t)._2){}
t}

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

Answer 18

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 111 बाइट्स

s=>{var t=s;do{s=t;t="";for(int i=0;i<s.Length;)t+=s[i]%48*(s[i++]!=(s+0)[i]?1:2*++i/i);}while(t!=s);return t;}

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

गोल्फिंग के लिए @ASCIIOnly ~ 30 के लिए बहुत बड़ा श्रेय;) पहले तो हम दोनों एक साथ अपडेट पोस्ट कर रहे थे, लेकिन किसी समय वह स्पष्ट रूप से शहर गया था!

-2 @EmbodimentOfIgnorance को धन्यवाद!

कम गोल्फ कोड ...

// s is the input as a string
s=>{
  // t is another string used
  // to hold intermediate results
  var t=s;
  // the algorithm repeatedly
  // processes s and saves the
  // result to t
  do{
    // copy the last result to s
    // and blank out t
    s=t;
    t="";
    // iterate over s
    for(int i=0;i<s.Length;)
      // append either 1 or 2 times
      // the current digit to t
      t+=s[i]%48*
        // compare the current digit
        // to the next digit. to prevent
        // an out-of-bounds exception,
        // append a 0 to s which either
        // gets ignored or collapses
        // to 0
        (s[i++]!=(s+0)[i]
          // if they are different, then
          // the multiplier is 1
          ?1
          // if they are the same, then
          // the multiplier is 2, and we
          // have to increment i
          :2*++i/i);
  }
  // continue this until the input
  // and output are the same
  while(t!=s);
  return t;
}

Comments

139

— ASCII-only

134

— ASCII- केवल

@ASCIIOnly - अच्छी चाल :) (s[i++]-48)*2=>s[i++]*2-96

— दाना

131

— ASCII- केवल

114

— ASCII- केवल