CUDDLE गणना

Question

69 नंबर पर विकिपीडिया पृष्ठ के अनुसार , यह ध्यान में रखा जाता है कि 69 ² = 4,761 और 69 ³ = 328,509 सभी दशमलव अंकों का उपयोग करते हैं। 69 की संख्या वास्तव में सबसे कम संख्या है जो इस संपत्ति को संतुष्ट करती है।

इसी तरह के कारण से, 32,043 उल्लेखनीय है: 32,043 ² = 1,026,753,849 सभी दशमलव अंकों का उपयोग करता है।

यदि हम संख्याओं के बारे में बात करते रहने वाले हैं जो इस तरह से दिलचस्प हैं, तो हमें कुछ अंकन की आवश्यकता होगी।

सबसे पूर्णांकों के लिए n , शक्तियों एन ² , ..., n ^{कश्मीर} सभी दस दशमलव अंक का उपयोग करेगा की पर्याप्त रूप से बड़े मूल्यों के लिए एक बार में कम से कम (अग्रणी शून्य गिनती नहीं) कश्मीर । यदि यह मौजूद है, हम सबसे कम इस तरह के फोन करता हूँ कश्मीर गले लगाएं ( संचयी दशमलव अंक, कम से कम घातांक का) n ।

कार्य

एक प्रोग्राम या एक फ़ंक्शन लिखें जो एक एकल गैर-नकारात्मक पूर्णांक n को इनपुट के रूप में स्वीकार करता है और अपनी CUDDLE की गणना और रिटर्न करता है ।

यदि n में CUDDLE नहीं है , तो आप कुछ भी कर सकते हैं लेकिन एक सकारात्मक पूर्णांक, जिसमें एक त्रुटि या एक रिक्त स्ट्रिंग शामिल है, जब तक कि आपका कोड अंततः रुक जाता है।

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

लेफ्ट कॉलम इनपुट है, राइट कॉलम आउटपुट है।

0 
1 
2          15
3          10
4          10
5          11
6          12
7           7
8           5
9           6
10 
11          7
12          6
13          6
14          7
15          9
16          5
17          7
18          4
19          5
20         15
26          8
60         12
69          3
128         3
150         9
200        15
32043       2
1234567890  3

अतिरिक्त नियम

• आपका कोड 255 तक के सभी इनपुट के लिए काम करना चाहिए ।

  ध्यान दें कि इसमें बहुत बड़ी संख्या के साथ काम करना शामिल है। 20 ¹⁵ पहले से ही 2 ⁶⁴ से बड़ा है ।

• यदि आप परिणाम को प्रिंट करते हैं, तो यह एक लाइनफीड द्वारा पीछा किया जा सकता है।

• मानक कोड-गोल्फ नियम लागू होते हैं।

Comments

मैं सोच रहा था कि हम CUDDLE से 69 में कैसे चले गए, और मुझे यह थोड़ा परेशान करने वाला लगता है कि इसे शक्ति के साथ क्या करना है?)

— हारून

यदि संख्या में कोई CUDDLE नहीं है, तो क्या यह ठीक है यदि प्रोग्राम रुकता है ... आखिरकार? (यानी जब पूर्णांक काउंटर overflows)

— दरवाज़े

इसके अलावा, पहले अतिरिक्त नियम के लिए: इसका मतलब यह है कि यदि आपकी भाषा के पूर्णांक प्रकार संख्याओं 255 को स्टोर कर सकते हैं, तो आपके कोड को उनके लिए काम करना होगा ?

— दरवाज़े

@Doorknob अंततः ठीक है, जब तक कि यह वास्तव में रुक जाता है। मैंने इनपुट पर 255 की ऊपरी सीमा लगाई है। अभी भी गणना में कुछ बहुत बड़ी संख्याएं शामिल हैं ...

— डेनिस

मैंने परीक्षण मामले को जोड़ा 26->8क्योंकि यह सबसे छोटा उदाहरण है जिसमें n^1गलत उत्तर ( जिनमें से 6), एक त्रुटि है जो मैंने अपने कोड में दी थी।

— xnor

Answer 1

पायथ, 16 बाइट्स

hf<9l{=+k^QTtS15

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

अन्य समाधानों की तरह, मैं 15 का उपयोग ऊपरी सीमा के रूप में करता हूं। मेरा मानना ​​है कि यह अधिकतम CUDDLE भी है । मैंने 10.000.000 तक सभी नंबरों का परीक्षण किया, और 15 से अधिक CUDDLE के साथ कोई संख्या नहीं है ।

CUDDLE > = 10 वाले नंबर पहले से ही काफी दुर्लभ हैं। 15 के CUDDLE वाले एकमात्र नंबर हैं 2*10^k। 14 या 13 के CUDDLE के साथ कोई संख्या नहीं है , CUDDLE 12 केवल संख्याओं के लिए प्रकट होता है 6*10^k, CUDDLE 11 केवल के लिए 5*10^k।

इसलिए मुझे लगता है कि यह कोड किसी भी प्राकृतिक संख्या के लिए पूरी तरह से काम करता है।

यदि कोई समाधान नहीं है, तो एक त्रुटि संदेश प्रिंट करता है।

स्पष्टीकरण:

hf<9l{=+k^QTtS15   implicit: Q = input number
                             k = empty string
            tS15   the list [2, 3, 4, ..., 15]
 f                 filter this list for elements T, which satisfy:
         ^QT          compute Q^T
       +k             k + ^ (converts to string implicitly)
      = k             save the result in k
    l{  k             length of set of k (number of different chars)
  <9                  test if 9 is smaller than ^
h                  print the first number in the filtered list
                   (throws error if empty)

Answer 2

अजगर 2, 56

f=lambda n,i=2,s='L':len(set(s))>10or-~f(n,i+1,s+`n**i`)

एक पुनरावर्ती समाधान। iसे शुरू होने वाले घातांक को गिनता है 2और n**iस्ट्रिंग में शक्तियों के अंकों को जमा करता है s। जब sसभी दस अंक होते हैं, तो रिटर्न True, जो बराबर होता है 1, और अन्यथा पुनरावृत्ति और जोड़ता है 1। यह वापसी से कम निकला i।

बिना CUDDLE के किसी संख्या पर फ़ंक्शन को कॉल करना समाप्त हो जाता है Internal error: RangeError: Maximum call stack size exceeded। 255उस नंबर तक के आउटपुट को 15 से अधिक पुनरावृत्तियों की आवश्यकता नहीं है।

पायथन 2 की एक Lबड़ी संख्या में आवेदन करने की कष्टप्रद आदत के कारण , हम वास्तव में अंक स्ट्रिंग की Lजांच करते हैं और जांचते हैं कि क्या सेट का आकार कम से कम 11. है। पायथन 3 को इसकी आवश्यकता नहीं होने से 2 चार्ट बचाता है, लेकिन strबैकटिक्स का उपयोग करके 3 चार्ट खो देता है । अजगर 3.5 सेट अनपैकिंग के साथ 2 और चार्ट बचाता है, कुल मिलाकर पायथन 2 पर एक चार्ट की बचत होती है:

f=lambda n,i=2,s='':len({*s})>9or-~f(n,i+1,s+str(n**i))

Answer 3

रूबी, 67 65 चार्ट

->n{s='';[*2..99].index{|i|(s+="#{n**i}").chars.uniq.size==10}+2}

लगभग सभी परीक्षण मामलों के लिए तत्काल काम करता है, यहां तक ​​कि> 255 भी।

बिना CUDDLE वाले संख्याओं के लिए त्रुटियां।

स्पष्टीकरण:

-> n {                         # define function with short lambda syntax
  s = ''                       # the string we are storing the numbers in
  [*2..99]                     # for all numbers from 2 to 99...
    .index {|i|                # find index of the number `i` for which...
      (s+="#{n**i}")           # after appending pow(n,i) to s...
        .chars.uniq.size==10}  # num of uniq chars in s is 10 (each digit)
  + 2                          # add 2, because our index starts from 2
}

Answer 4

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

LliG,2>f#{s+_&_}%:,A#)_)s\g*

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

यह इस तथ्य पर निर्भर करता है कि इनपुट रेंज के लिए CUDDLE (यदि यह मौजूद है) 15 से बड़ा नहीं है, जैसा कि @xnor द्वारा पहली बार देखा गया था।

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

स्पष्टीकरण:

L     Push empty string, will be used for accumulating digits.
li    Get input and convert to integer.
G,    Build list of exponents [0 .. 15].
2>    Slice off first two values, to produce [2 .. 15].
f#    Apply power operator with all exponents to input.
{     Start loop over powers.
  s     Convert to string. We care about the digits here.
  +     Concatenate with previously found digits.
  _&    Uniquify using set intersection of digit list with itself.
  _     Copy for continued accumulation in next loop iteration.
}%    End of loop over powers. We'll have an extra copy of the last value here,
      but it does no harm so we just keep it.
:,    Apply length operator to accumulated digit lists.
A#    Find 10 in the list. The search result will correspond to the first power
      that resulted in 10 different accumulated digits. If not found, the result
      will be -1. Note that 0 corresponds to power 2, since that was the first
      power we used. So we need to add 2 to get the result, and check for -1.
)     Increment value. 0 now corresponds to no solution.
_     Copy this value. Will be used as multiplier to create empty string if 0.
)     Increment again, to get the +2 needed for the result.
s     Convert to string.
\     Swap once-incremented value to top, which is 0 for no solution, non-zero
      otherwise.
g     Signum to get 0/1 for no solution vs. solution.
*     Multiply with result string, to get empty string for no solution.

Answer 5

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

f=(d=DigitCount;x=1;y=d[0];For[n=0,!IntegerQ@Log10[#]&&MemberQ[y,0],++n,x*=#;y+=d[x]];Print[#,"\t",n])&

ऐसा प्रतीत होता है कि केवल 10 की शक्तियों में अंततः CUDDLEs नहीं होंगे, इसलिए उन्हें छोड़ दिया जाता है। फ़ंक्शन देखे गए अंकों की एक सूची रखता है और तब रुकता है जब उसमें शून्य नहीं होते हैं।

आउटपुट:

1    0
2    15
3    10
4    10
5    11
6    12
7    7
8    5
9    6
10    0
11    7
12    6
13    6

Comments

मजेदार तथ्य: जब तक log_10(n)तर्कहीन है, तब तक किसी भी सकारात्मक पूर्णांक को देखते हुए kऐसा मौजूद है mकि दशमलव का प्रतिनिधित्व n^mशुरू होता है k। जिसका अर्थ है कि 10 (और 0) की शक्तियों को

— छोड़ना

Answer 6

जावास्क्रिप्ट (ईएस 6) 188

53 बिट्स पूर्णांक तक सीमित होने वाली भाषा के लिए बुरा नहीं है।

नीचे दिए गए स्निपेट को एक ब्राउज़र में टेस्ट करें जो कि एक्मा स्क्रिप्ट्स 6 को लागू करता है, जिसमें एरो फ़ंक्शंस और स्प्रेड ऑपरेटर (AFBIKS) शामिल हैं

f=n=>{for(p=1,d=[],v=n=[...n+''].reverse();++p<20;){v.map((a,i)=>n.map((b,j)=>r[j+=i]=a*b+~~r[j]),r=[],c=0),r=r.map(r=>(r+=c,c=r/10|0,d[r%=10]=r));v=c?[...r,c]:r;if(d.join``[9])return p;}}

// Less golfed
U=n=>{
// Arbitrary precision multiplication
  M=(A,B,R=[],c=0)=>
  (
    A.map((a,i)=>B.map((b,j)=>R[j+=i]=a*b+~~R[j])),
    R=R.map(r=>(r+=c,c=r/10|0,r%10)),
    c?[...R,c]:R
  );
  v=n=[...n+''].reverse();
  for(p=1,d=[];++p<20;)
  {
    v=M(n,v)
    
    v.map(c=>d[c]=c)
    if (d.join``[9])return p
  }  
}

// TEST
for(i=o='';++i<300;)o+=i+' : '+f(i)+'\n'
O.innerHTML=o
  
  

<pre id=O></pre>

Answer 7

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

param($n,$s='')
2..99|%{$s+=[bigint]::Pow($n,$_);if(($s-split''|sort -U).Count-eq11){$_;break}}

(As a single line)

इसके बारे में बहुत चालाक कुछ भी नहीं है, लेकिन इस तरह के उपयोग के लिए sort -U[nique]एपिथॉन की set()कार्यक्षमता के लिए पाइपिंग एक साफ तरीका है , बिना स्पष्ट रूप से आइटम को हैशटेबल में जोड़ना।

param($n,$s='')                              # Take command line parameter.
2..99 |%{                                    # Loop from 2 to 99, inclusive.
    $s+=[bigint]::Pow($n,$_)                 # $n^Loopvar, concatenate to string.
    if (($s-split''|sort -U).Count-eq11) {   # Convert to unique-characters-array; count.
        $_;break                             # Print current loopvar and quit.
    }
}                                            # Otherwise, finish (silently).

जैसे

PS C:\> .\CUDDLE-of-n.ps1 10

PS C:\> .\CUDDLE-of-n.ps1 12
6

PS C:\> .\CUDDLE-of-n.ps1 255
5

Answer 8

gawk 4, 73 + 5 झंडे के लिए = 78 बाइट्स

{for(n=$0;a-1023&&++i<15;j=0)for($0*=n;j++<NF;)a=or(a,2^$j)}$0=i<15?++i:_

प्रत्येक अंक 0बीआईएस के लिए 9यह इनपुट की शक्तियों में सामना करता है, यह बिट का प्रतिनिधित्व करता 2^digitहै a, जब तक कि पहले 10 अंक नहीं मिलते हैं ( a == 1023 == 2^10-1) या 15 से अधिक पुनरावृत्तियों हुए हैं।

को बड़ी संख्या के लिए एक खाली क्षेत्र सेपरेटर और -M ध्वज के साथ बुलाया जाना है।

echo 17 | awk -M '{for(n=$0;a-1023&&++i<15;j=0)for($0*=n;j++<NF;)a=or(a,2^$j)}$0=i<15?++i:_' FS=

इसके आसपास की हलचल मुझे अलग-अलग CUDDLE के लिए निम्नलिखित अनुक्रम मिली:

2: 32043 32286 33144 35172 35337 35757 35757 37176 37906 37772 39147 39337 395 6 40545 42744 43902 44016 45567 45624 4656854 49514 49353 50706 53976 54918 55581 5558181 5558181 55581817558181755818175581 68781 69513 71433 72621 75759 76047 76182 77346 78072 78453 80451 80445 81222 81945 83945 83919 84648 85353 85743 85803 88073 87639 88623 89795 89955 89955 89523 80123 9014490153333017333337333337337
3: 69 128 203 302 327 366 396 467 542 591 593 593 598 633 643 690 747 759 903 923 943 943 1016 1027 1028 1086 1186 1182 1182 1194 1299 1233 1280 82 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 14 13 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 1509 1519 1563 1569 1599 1602 1603 1603 1631 1631 1633 1634 1659 1669 1687 1701 1712 1737 1737 1767 1774 1778 1780 1791 174 18037 1844 1869 1895 1895 1899 1903 1921 1936 1956 1958 1960 1962 1973 1954 1954, 1994, 2005, 2017, 2017, 2017, 2017, 2017, 2017 2053 2075 2123 2126 2134 2157 2158 2159 2168 2175 2183
४: १ 112 ५४ ५: ६ 84 93१ 95 95 ९ 95 97 ९ 108५ १५० १५० १५४ १३५ १४५ १४५ १४५ १५ 156 १५ 156 १५ 159 १५ 17 १५ 18 १4 18 १4 18 १2 18 १2 180 १ 179 180 १ 179 180 १6४ १ 67४ १ ९ २ २११ २११ २११ २१ 22 २१२ २२ 22 २२ 22 २३ 232 २३२ २३२ २३२ २३ ९ २४8 २४8 २४५ २६५ हो गए। 266 267 270 272 273 279 281 285 287 294 298 299 306 311 311 314 315 316 323 326 326 326 336 348 343 353 354 356 351 362 364 364 368 369 379 378 393 395 396 396 393 403 413 413 416 416 416 416 416 416 416 416 431 434 439 442 443 443 444 448 451 452 453 454 455 457 457 459 463 466 469 472 473 477 482 484 486 489 493 494 496 506 507 508 509 515 517 517 523
५: 61 १६ १ ९ २ 55 २ 38 ३ 44 ४४ ४ 55 ५ 55 ५ 8 79१ 82० 27० 27० 87३ 87३ 16६ 16६ १ ९ 16६ १०३ ११३ ११३ १११ ११३ १२१ १२५ १२३ १३१ १३२ १४५ १४५ १६५ १६५ १६५ १६५ बने रहना चाहिए 173 175 176 177 183 185 186 187 189 190 19 19 19 19 19 19 19 19 198 204 207 218 224 226 229 230 231 236 240 243 246 249 253 255 257 258 259 263 263 26 26 26 27 27 27 27 27 27 27 27 28 28 28 28 28 28 28 28 28 29 29 29 29 29 29 29 29 29 29 28 296 293 304 309 322 328 331 339 341 344 345 346 346 348 349 352 357 359 357 377 372 373 374 377 377 380 381 384 387 389 389 409 407 408 409 411 417 418 422 427 422 427!
6: 9 12 13 22 23 24 33 36 37 39 42 43 45 46 49 51 53 58 62 66 72 73 75 78 81 88 90 94 98 105 107 109 114 119 120 122 127 130 134 137 149 153 155 162 163 164 166 168 170 194 199 206 211 212 219 220 222 225 233 237 238 244 247 252 254 256 262 264 274 294 295 296 301 308 317 319 329 324 325 330 333 333 337 351 355 358 378 378 388 383 385 386 390 394 399 399 399 393 401 404 405 406 415 420 421 424 425 429 430 433 435 438 446 4506 476 471 476 478 488 490 498 502 504 510 513 513 514 519 530 539 530 539 556 576 620 628 631 634 636 636
: 52 ११ १४ १ 48 २ ९ ३१ ३२ ३५ ४१ ४४ ५२ ५६ ६४ 70६ 85६ 96६ 102६ ९ ६४ १२० १११ १११ १११ १११ २०१ २०१ २०५ २०५ २०५ २५० २ ९ २ ३ ९ ३ ३०३ ३१ 310 ​​३१ 31 ३१५ ३५५ ३५५ ३६५ ३६५ ३५ 465 475 480 483 485 501 511 518 520 521 560 582 584 595 595 601 630 682 700 736 740 786 798 850 890 952 956 975 975 990 990 999 1002 1015 10120 2040 1054 1100 1110 1171 1219 1331 1350 1350 1379 1379 1414 1447 1468 1668 170 1710 1735 1748 2001 2010 2020 2050 2080 2450 2510 2534 2641 2745 2900 2914 2955 2970 3030 3050 3070 3100 3130 3136 3180 3193 3200
8: 21 25 26 30 34 65 76 124 209 210 250 260 300 340 505 650 100 1004 1240 2002 2090 2100 2500 2600 2900 3000 3400 3944 4376 5050 6500 6800 7340 7340 10040 15483 262 20020 20900 21000 26000 29000 30000 43760 50500 6588 68850 73,990 
9: 15 68 101 150 1001 1010 1500 10001 10010 10100 15000 
10: 3 4 40 400 4000 40000 
11: 5 50 500 5000 50000 
12: 6 60 600 6000 60000 
15: 2 20 200 2000 20000