योगात्मक दृढ़ता


20

सभी संभावनाओं को जीतने के लिए सबसे छोटा कोड जीतता है।

गणित में, एक संख्या की दृढ़ता मापती है कि किसी निश्चित निश्चित स्थिति तक पहुंचने तक किसी निश्चित ऑपरेशन को उसके अंकों पर कितनी बार लागू किया जाना चाहिए। आप पूर्णांक के अंकों को जोड़कर और दोहराते हुए एक सकारात्मक पूर्णांक के योगात्मक दृढ़ता को निर्धारित कर सकते हैं। आप तब तक योग के अंकों को जोड़ते रहेंगे, जब तक कि एक अंक का अंक न मिल जाए। पुनरावृत्ति की संख्या उस एकल अंक तक पहुंचने के लिए उस संख्या का योगात्मक दृढ़ता है।

84523 का उपयोग करके उदाहरण:

84523
8 + 4 + 5 + 2 + 3 = 22
2 + 2 = 4

It took two repetitions to find the single digit number.
So the additive persistence of 84523 is 2.

आपको सकारात्मक पूर्णांकों का एक क्रम दिया जाएगा, जिसके लिए आपको योगात्मक दृढ़ता की गणना करनी होगी। प्रत्येक पंक्ति में प्रक्रिया करने के लिए एक अलग पूर्णांक होगा। इनपुट किसी भी मानक I / O विधियों में हो सकता है ।

प्रत्येक पूर्णांक के लिए, आपको पूर्णांक को आउटपुट करना होगा, इसके बाद एकल स्थान, इसके बाद इसकी निरंतर दृढ़ता। संसाधित किया गया प्रत्येक पूर्णांक अपनी लाइन पर होना चाहिए।

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


इनपुट आउटपुट

99999999999 3
10 1
8 0
19999999999999999999999 4
6234 2
74621 2
39 2
2677889 3
0 0

1
आपके परीक्षण के मामलों में कुछ मूल्य शामिल हैं जो 2 ^ 64 से अधिक हैं, और आपकी कल्पना कहती है कि कार्यक्रम को केवल 2 ^ 32 तक मानों को संभालना है। यह समाशोधन के लायक हो सकता है।
पीटर टेलर

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

5
क्या 999999999999 की दृढ़ता 2 के बजाय 3 नहीं है?
बारहवीं

@Evelex, मुझे लगता है कि एक गलत अंतिम मिनट परिवर्तन था। फिक्स्ड।
केविन ब्राउन

यहां कई उत्तर स्टडआउट पर आउटपुट नहीं कर रहे हैं, बल्कि कमांड लाइन इनपुट लेने के बाद परिणाम वापस करके जे के "इंटरैक्टिव" आउटपुट का उपयोग करते हैं। (इसमें 2 अन्य J उत्तर शामिल हैं और, मैं अनुमान लगा रहा हूं, K उत्तर।) क्या इसे वैध माना जाता है? क्योंकि मैं 18-ईश पात्रों को बहा सकता हूं यदि ऐसा है।
जेसी मिलिकन

जवाबों:


6

K - 29 शुल्क

इनपुट एक फ़ाइल नाम है जिसे तर्क के रूप में पारित किया जाता है, फ़ाइल नाम सहित 29 वर्ण नहीं।

`0:{5:x,-1+#(+/10_vs)\x}'.:'0:"file"
  • 35 -> 31: बाहरी फ़ंक्शन को निकालें।
  • 31 -> 29: Parens निकालें।


4

पायथन 84 चार्ट

while 1:
 m=n=int(raw_input());c=0
 while n>9:c+=1;n=sum(map(int,str(n)))
 print m,c

चुनौती का मामला: 06234.. परिणाम सफल चुनौती :-)
Quixotic

@ डिबंजन धन्यवाद सही किया।
fR0DDY


4

पायथन (93 बाइट्स)

f=lambda n,c:n>9and f(sum(map(int,str(n))),c+1)or c
while 1:n=int(raw_input());print n,f(n,0)

मुझे लगता है कि आप 9और and
इरेट के

@ st0le: धन्यवाद :-)
Quixotic

और उसके input()बजाय int(raw_input())....
st0le

@ st0le: इस इनपुट को उस संशोधन के साथ आज़माएँ 06234:।
Quixotic

4

भूसी , 10 15 बाइट्स

भयानक I / O आवश्यकता के लिए +5 बाइट्स

m(wΓ·,LU¡oΣdr)¶

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

व्याख्या

कई आदानों का समर्थन करने के लिए, हमें उपयोग करने की आवश्यकता है m(₁r)¶(जहां फ़ंक्शन दिलचस्प गणना कर रहा है):

m(₁r)¶  -- expects newline-separated inputs: "x₁␤x₂␤…␤xₙ"
     ¶  -- split on newlines: ["x₁","x₂",…,"xₙ"]
m(  )   -- map over each string
 ( r)   -- | read integer: [x₁,x₂,…,xₙ]
 (₁ )   -- | apply the function described below

निम्नलिखित कार्य करता है:

wΓ·,LU¡(Σd)  -- input is an integer, eg: 1234
      ¡(  )  -- iterate the following forever and collect results in list:
       ( d)  -- | digits: [1,2,3,4]
       (Σ )  -- | sum: 10
             -- : [1234,10,1,1,1,…
     U       -- keep longest prefix until repetition: [1234,10,1]
 Γ           -- pattern match (x = first element (1234), xs = tail ([10,1])) with:
  · L        -- | length of xs: 2
   ,         -- | construct tuple: (1234,2)
w            -- join with space: "1234 2"

3

बैश, 105 वर्ण

while read x
do
for((i=0,z=x;x>9;i++))do
for((y=0;x>0;y+=x%10,x/=10))do :
done
x=$y
done
echo $z $i
done

शायद ही कोई गोल्फिंग वास्तव में शामिल है, लेकिन मैं यह नहीं देख सकता कि इसे कैसे सुधारना है।



3

रूबी, 85 शुल्क

puts $<.map{|n|v=n.chop!;c=0;[c+=1,n="#{n.sum-n.size*48}"] while n[1];[v,c]*' '}*"\n"

मुझे एलेक्स से "योग-आकार * 48" विचार उधार लेना पड़ा, क्योंकि यह केवल याद करने के लिए बहुत साफ है (कम से कम रूबी में)।


3

गोल्फस्क्रिप्ट, 40 चार्ट

n%{.:${;${48-}%{+}*`:$,}%.,1>\1?+' '\n}%

3

जे - 45 शुल्क

स्टड से पढ़ता है

(,' ',[:":@<:@#+/&.:("."0)^:a:)&><;._2(1!:1)3

मैं ^:a:अपने आप को इस्तेमाल करने की कोशिश कर रहा था, लेकिन मुझे कुछ उचित दस्तावेज नहीं मिले ... कोई संकेत?
12

1
यू के लिए शब्दकोश प्रविष्टि ^: n इसके उपयोग के बारे में जानकारी है, लेकिन यह थोड़ा घना है। ^: a किसी भी अन्य कॉल की तरह है, लेकिन यह परिणाम एकत्र करता है और समाप्त होता है जब लगातार कॉल का तर्क समान होता है (परिवर्तित)।
isawdrones

1
@ बारहवीं एफडब्ल्यूआईडब्ल्यू मैंने जे संदर्भ कार्ड [पीडीएफ] में ट्रिक के a:माध्यम से खोजा^:a:
जेबी

@ जेबी: यह केवल ^:a:उस संदर्भ पर है जो मुझे पता था: डी
एलेक्स मार्क्स 27'11

@ ईवेक्स ओह। मुझे तब विपरीत अनुभव हुआ था। मैंने शब्दकोश में कार्यक्षमता की खोज की, और इसे ^:(<'')पहले (शायद कपरेकर के लिए) कुछ संस्करण के रूप में इस्तेमाल किया , जब तक कि मैंने इसे कार्ड में नहीं देखा, और a:इस अवसर के बारे में सीखा ।
JB

3

c - 519

(या 137 यदि आप मुझे ढांचे के लिए श्रेय देते हैं ...)

केवल इस एक ऑपरेशन को हल करने के बजाय, मैंने सभी दृढ़ता समस्याओं को हल करने के लिए एक रूपरेखा तैयार करने का फैसला किया ।

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef char*(*O)(char*);
char*b(char*s){long long int v=0,i,l=0;char*t=0;l=strlen(s);t=malloc(l+2);
for(i=0;i<l;i++)v+=s[i]-'0';snprintf(t,l+2,"%lld",v);return t;}
int a(char**s,O o){int r;char*n;n=o(*s);r=!strcmp(*s,n);free(*s);
*s=n;return r;}
int main(int c, char**v){size_t l, m=0;char *d,*n=0;O o=b;FILE*f=stdin;
while(((l=getline(&n,&m,f))>1)&&!feof(f)){int i=0;n=strsep(&n,"\n");
d=strdup(n);while(!a(&n,o))i++;printf("%s %d\n",d,i);free(d);free(n);n=0;m=0;}}

char*bइस समस्या के लिए केवल दो लाइनें शुरू होती हैं जो अद्वितीय हैं।

यह इनपुट को स्ट्रिंग्स के रूप में मानता है, जिसका अर्थ है कि आउटपुट चरण से पहले प्रमुख "0" पट्टी नहीं है।

ऊपर टिप्पणी, त्रुटि जाँच और रिपोर्टिंग, और फ़ाइल पढ़ने (इनपुट इनपुट मानक इनपुट से आना चाहिए) से बाहर धारीदार है:

/* persistence.c
 *
 * A general framework for finding the "persistence" of input strings
 * on opperations.
 *
 * Persistence is defined as the number of times we must apply
 *
 *    value_n+1 <-- Opperation(value_n)
 *
 * before we first reach a fixed point.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../getline.h"

/* A function pointer type for operations */
typedef char*(op_func)(char*);
typedef op_func* op_ptr;
/* Op functions must
 * + Accept the signature above
 * + return a point to a newly allocated buffer containing the updated str
 */

char* addop(char*s){
  int i,l=0;
  long long int v=0;
  char *t=NULL;
  /* protect against bad input */
  if (NULL==s) return s;
  /* allocate the new buffer */
  l = strlen(s);
  t = malloc(l+2);
  if (NULL==t) return t;
  /* walk the characters of the original adding as we go */
  for (i=0; i<l; i++) v += s[i]-'0';
  //fprintf(stderr,"   '%s' (%d) yields %lld\n",s,l,v);
  snprintf(t,l+2,"%lld",v);
  //fprintf(stderr,"   %lld is converted to '%s'\n",v,t);
  return t;
}

/* Apply op(str), return true if the argument is a fixed point fo
 * falsse otherwise,
 */ 
int apply(char**str, op_ptr op){ 
  int r;
  char*nstr;
  /* protect against bad input */
  if ( NULL==op ) exit(1); 
  if ( NULL==*str ) exit(4); 
  /* apply */
  nstr = op(*str); 
  /* test for bad output */
  if ( NULL==nstr ) exit(2); 
  r = !strcmp(*str,nstr); 
  /* free previous buffer, and reasign the new one */
  free(*str); 
  *str = nstr; 
  return r; 
}

int main(int argc, char**argv){
  size_t len, llen=0;
  char *c,*line=NULL;
  op_ptr op=addop;
  FILE *f=stdin;
  if (argc > 1) f = fopen(argv[1],"r");
  while( ((len=getline(&line,&llen,f))>1) && line!=NULL && !feof(f) ){
    int i=0;
    line=strsep(&line,"\n"); // Strip the ending newline
    /* keep a copy for later */
    c = strdup(line);
    /* count necessary applications */
    while(!apply(&line,op)) i++;
    printf("%s %d\n",c,i);
    /* memory management */
    free(c);
    free(line);
    line=NULL;
    llen=0;
  }
}

यदि हम छलनी की तरह स्मृति को लीक करने के लिए तैयार थे तो थोड़ा और बचाया जा सकता है। इसी तरह से #defineवापसी और इस तरह से, लेकिन इस बिंदु पर मैं इसे किसी भी बदसूरत बनाने के लिए परवाह नहीं है।



2

जे, 74 चरस

i=:<;._2(1!:1)3
i&((],' ',":@(0 i.~9<[:".([:":[:+/"."0)^:(i.9)))@>@{~)i.#i

संपादित करता

  • ((६ → to३)[: चींटियों को कुछ टोपियां@
  • ((३ →। ९) अज्ञात माता-पिता
  • (79 → 75) बदलने 0".के लिए ".सरल बातें
  • (75 → 74) बेहतर काटना

उदाहरण के लिए

i=:<;._2(1!:1)3
74621
39
2677889
0
i&((],' ',":@(0 i.~9<[:".([:":[:+/"."0)^:(i.9)))@>@{~)i.#i
74621 2  
39 2     
2677889 3
0 0  

आउटपुट कई इनपुट के लिए गलत स्वरूपित है। "सिंगल स्पेस" देखें
जेसी मिलिकन

@ जेसे: मुझे कुछ भी गलत नहीं दिख रहा है। क्या आप कृपया एक उदाहरण लिख सकते हैं?
बारहवीं

मुझे कोई पता नहीं है, मैं उन चीजों को देख रहा हूं जो मुझे लगता है।
जेसी मिलिकन

1

मुझे लगता है कि यह मेरे बारे में सबसे अच्छा हो सकता है।

रूबी 101 शुल्क

f=->(n){n.sum-n.size*48}
$<.each{|l|i=0;i+=1 while(i+=1;n=f[(n||l.chop!).to_s])>10
puts "#{l} #{i}"}

असल में, चॉप! के बजाय chomp! मुझे एक चरित्र बचत देता है। 97 वर्ण।
एलेक्स बार्टलो

बस इस पर कुछ और गोल्फिंग किया - 91 चार्ट।
एलेक्स बार्टलो

1

PARI / GP 101 शुल्क

s(n)=r=0;while(n>0,r+=n%10;n\=10);r
f(n)=c=0;while(n>9,c++;n=s(n));c
while(n=input(),print(n," ",f(n)))

दुर्भाग्य से, GP के लिए कोई इनपुट फ़ंक्शन नहीं है, इसलिए मुझे लगता है कि इसमें IO भाग की कमी है। :( फिक्स्ड: धन्यवाद!


ज़रूर है: input():)
आठवीं

@ बारहवीं, किया। :)
st0le

1

जावास्क्रिप्ट - 95

i=prompt();while(i>9){i=''+i;t=0;for(j=0;j<i.length;j++)t+=parseInt(i.charAt(j));i=t;}alert(t);

संपादित करें: व्हॉट्स मल्टी-लाइन्स नहीं करता है


1
बस यह सही ढंग से उत्पादन नहीं करता है देखा।
केविन ब्राउन

1

जे, 78

f=:[:+/"."0&":
r=:>:@$:@f`0:@.(=f)
(4(1!:2)~LF,~[:":@([,r)".@,&'x');._2(1!:1)3

पुनरावर्ती समाधान। स्टड से पढ़ता है। स्टडआउट को लिखता है , इसलिए मुझे कुछ सुस्त काट दें - यह एक अतिरिक्त 18-ईश अक्षर लेता है।


1

पर्ल - 77 अक्षर

sub'_{split//,shift;@_<2?0:1+_(eval join'+',@_)}chop,print$_,$",(_$_),$/for<>

1

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

-10 बाइट्स @ l4m2 की बदौलत!

f=(s,c=0)=>s>9?f(eval([...s+""].join`+`),++c):c

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


f=(s,c=0)=>s>9?f([...s+""].reduce((x,y)=>x*1+y*1),++c):c
l4m2

f=(s,c=0)=>s>9?f([...s+""].reduce((x,y)=>x- -y),++c):c
l4m2

1
f=(s,c=0)=>s>9?f(eval([...s+""].join`+`)),++c):c
l4m2

@ l4m2 धन्यवाद! s>9और evalमहान विचार थे। मुझे लगता है कि आपके पास वहां एक अतिरिक्त पेरेन था, इसे कुल 10 बाइट्स बनाने से आपने मुझे बचाया :-)
ओलिवर

नोट सख्त आई / ओ;)
शैगी

1

05AB1E , 13 बाइट्स

ε.µΔSO¼}¾}<ø»

पूर्णांकों की सूची के रूप में इनपुट।

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

स्पष्टीकरण:

ε     # Map each integer in the (implicit) input to:
    #  Reset the counter variable to 0
 Δ    #  Loop until the integer no longer changes:
  S   #   Convert it to a list of digits
   O  #   And take the sum of those
  ¼   #   Increase the counter variable by 1
    #  After the inner loop: Push the counter variable
}<    # After the map: decrease each value by 1
  ø   # Zip/transpose it with the (implicit) input to create a paired list
   »  # Join each pair by a space, and then each string by newlines
      # (after which the result is output implicitly)

1

मैथॉल्फ , 11 बाइट्स

hÅ_Σ]▀£(k ?

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

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

इस तथ्य का उपयोग करता है कि योगात्मक दृढ़ता संख्या के अंकों की संख्या से कम या बराबर है। अब आसानी से सभी परीक्षण मामलों को पास करता है।

इनपुट प्रारूप, जबकि कुछ भाषाओं के लिए उप-रूपी है, वास्तव में MathGolf में इनपुट के रूप में कई परीक्षण मामलों को लेने का मानक तरीका है। इनपुट की प्रत्येक पंक्ति को अपने स्वयं के प्रोग्राम निष्पादन के रूप में संसाधित किया जाता है, और आउटपुट को प्रत्येक निष्पादन के लिए एक नई लाइन द्वारा अलग किया जाता है।

स्पष्टीकरण (उपयोग करके n = 6234)

h             push length of number without popping (6234, 4)
 Å            loop 4 times using next 2 operators
  _           duplicate TOS
   Σ          get the digit sum
    ]         wrap stack in array
              this gives the array [6234, 15, 6, 6, 6]
     ▀        unique elements of string/list ([6234, 15, 6])
      £       length of array/string with pop (3)
       (      decrement (2)
        k ?   push input, space, and rotate top 3 elements to produce output (6234 2)


1

स्टैक्स , 8 11 बाइट्स

ªwæMε∞ö?îm⌐

इसे चलाएं और डीबग करें

+3 बाइट्स @Khuldraeseth के लिए धन्यवाद (पहले जवाब के अनुरूप उत्पादन नहीं था)


1
मैं उसी समाधान पर पहुंचा, लेकिन iइसके स्थान पर u। ड्रैकोनियन आईओ विनिर्देशों का पालन करते हुए, यह 11 बाइट्स बन जाता है ।
खुल्द्रेसथ ना'बर्या

उफ़। मुझे लगता है कि मैंने IO आवश्यकताओं को बहुत अच्छी तरह से नहीं पढ़ा है। मैं अपना जवाब अपडेट करूंगा।
पुनरावर्ती



0

जावा (ओपनजेडके 8) , 79 बाइट्स

a->{int d=0;while(a/10>0){int c=0;d++;while(a>0){c+=a%10;a/=10;}a=c;}return d;}

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

इसे आगे बढ़ाने की संभावित संभावना है, लेकिन मैं भविष्य में उस पर ध्यान दूंगा, लेकिन अभी के लिए, मैं इस छोटे से परिणाम से बहुत खुश हूं।




0

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

while 1:f=lambda n:n//10and 1+f(sum(map(int,str(n))));i=input();print(i,f(int(i)))

0

Tcl , 95 बाइट्स

proc P {v n\ 0} {set V $v
while \$v>9 {set v [expr [join [split $v ""] +]]
incr n}
puts $V\ $n}

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


3
क्योंकि अगला नवीनतम उत्तर पूर्ण 6 वर्ष का है, जो मुझे लगता है कि TIO के अस्तित्व में आने से पहले है
fəˈnɛt'k

0

जाप , 28 बाइट्स

Ë+S+(@D=X©A<D©ì x ªD D<AÃa÷
Ë                            // Map over the inputs and return each, followed by
 +S+                         // a space, followed by the number's persistence.
      D=     ©ì x            // To find it, fold the number up
        X©A<D     ªD         // if we can (handles unfoldable cases),
    (@               D<AÃa   // until it can't be folded up any further.
                          ÷ // Then, join everything up with newlines.

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


0

PHP, 72 + 1 बाइट्स

-Rझंडे के लिए +1 ।

for($i=0,$a=$argn;$a>9;$i++)$a=array_sum(str_split($a));echo"$argn $i
";

साथ पाइप के रूप में चलाएँ -R

  • PHP को पाइप के रूप में चलाने से हर इनपुट लाइन के लिए एक बार कोड निष्पादित होगा
  • लेकिन यह वैरिटेबल वैरिएबल को अनसेट नहीं करता है; इसलिए $iआरंभ किया जाना चाहिए।
    (इसके अलावा, यह 0आरंभीकरण के बिना एकल अंकों के बजाय कुछ भी नहीं प्रिंट करेगा ।)

0

बैश + कोरुटिल्स, 83 बाइट्स

[ $1 -le 9 ]&&exit $2
let x=$2+1
for z in `fold -w1<<<$1`
do let y+=$z
done
a $y $x

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

aसिस्टम नामक एक स्क्रिप्ट में सहेजा जाना चाहिए PATH, क्योंकि यह खुद को पुनरावर्ती कहता है। कमांड लाइन से इनपुट लेता है, जैसे a 1999। एग्जिट कोड द्वारा रिटर्न।

TIO की स्क्रिप्ट के साथ आप क्या कर सकते हैं, इसकी कुछ सीमाएँ हैं, इसलिए हेडर में इस रन को बनाने के लिए कुछ बॉयलरप्लेट कोड है।

stderrबैश पूर्णांक से बड़ी इनपुट के लिए एक त्रुटि प्रिंट कर सकते हैं, लेकिन चूंकि वास्तविक गणना स्ट्रिंग्स के साथ की जाती है, यह अभी भी वैसे भी सही परिणाम देता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.