จากหน้าวิกิพีเดียในหมายเลข 69มีข้อสังเกตว่า69 ² = 4,761และ69 ³ = 328,509ใช้ตัวเลขทศนิยมทั้งหมดร่วมกัน ในความเป็นจริงจำนวน69จำนวนต่ำสุดที่ตรงกับคุณสมบัตินี้

ด้วยเหตุผลที่คล้ายคลึงกัน32,043นั้นน่าทึ่ง: 32,043 ² = 1,026,753,849ใช้ตัวเลขทศนิยมทั้งหมด

หากเรากำลังพูดถึงตัวเลขที่น่าสนใจเช่นนี้ต่อไปเราจะต้องมีสัญลักษณ์

สำหรับจำนวนเต็มที่สุดnอำนาจn ² , ... , n ^kจะใช้ตัวเลขทศนิยมสิบ (ไม่นับเลขศูนย์นำ) อย่างน้อยหนึ่งครั้งค่ามากพอของk ถ้ามันมีอยู่แล้วเราจะเรียกต่ำสุดเช่นk กอด ( สะสมทศนิยมตัวเลข Exponent น้อย ) ของn

งาน

เขียนโปรแกรมหรือฟังก์ชั่นที่ยอมรับจำนวนเต็มเดียวที่ไม่ใช่เชิงลบnเป็น input และคำนวณและผลตอบแทนของมันกอด

หาก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 ⁶⁴แล้ว

• หากคุณพิมพ์ผลลัพธ์มันอาจตามด้วยตัวป้อนบรรทัด

• ใช้กฎมาตรฐานของกอล์ฟ

Pyth, 16 ไบต์

hf<9l{=+k^QTtS15

ลองใช้ออนไลน์: การสาธิตหรือชุดทดสอบ

เช่นเดียวกับโซลูชันอื่น ๆ ฉันใช้ 15 เป็นขีด จำกัด บน ผมเชื่อว่าเรื่องนี้ก็เป็นสูงสุดกอด ฉันทดสอบตัวเลขทั้งหมดมากถึง 10,000,000 และไม่มีตัวเลขที่มีCUDDLEมากกว่า 15

ตัวเลขที่มีCUDDLE > = 10 นั้นค่อนข้างหายากอยู่แล้ว ตัวเลขเฉพาะกับกอด 15 2*10^kเป็นตัวเลข มีจำนวนที่มีไม่มีกอด 14 หรือ 13 ที่กอด 12 จะปรากฏเฉพาะสำหรับตัวเลข6*10^kที่กอด 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)

Python 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เรื่องนี้กลายสั้นกว่าจะกลับ

Internal error: RangeError: Maximum call stack size exceededฟังก์ชั่นการโทรในตัวเลขโดยไม่มีสิ้นสุดกอดด้วย ตัวเลขที่มากถึง255เอาต์พุตนั้นไม่ต้องการการวนซ้ำมากกว่า 15 ครั้ง

เนื่องจากนิสัยที่น่ารำคาญของ Python 2 ต่อท้ายLจำนวนมากเราจึงเริ่มต้นสตริงหลักLและตรวจสอบว่าขนาดที่ตั้งไว้อย่างน้อย 11 Python 3 บันทึก 2 ตัวอักษรโดยไม่จำเป็นต้องใช้นี้ แต่สูญเสีย 3 ตัวอักษรที่ใช้strบน backticks Python 3.5 บันทึกอีก 2 ตัวอักษรด้วยการแกะกล่องออกและบันทึก char มากกว่า Python 2 ทั้งหมด:

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

Ruby, 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
}

CJam, 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.

Mathematica, 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 เท่านั้นที่จะไม่มี CUDDLE ในที่สุดดังนั้นจึงถูกข้ามไป ฟังก์ชั่นเก็บรายการตัวเลขที่เห็นและหยุดเมื่อไม่มีเลขศูนย์ในนั้น

เอาท์พุท:

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

JavaScript (ES6) 188

ไม่เลวสำหรับภาษาที่ จำกัด จำนวนเต็ม 53 บิต

ทดสอบการเรียกใช้ข้อมูลโค้ดด้านล่างในเบราว์เซอร์ที่ใช้ EcmaScripts 6 รวมถึงฟังก์ชั่นลูกศรและตัวดำเนินการแพร่กระจาย (AFAIK Firefox)

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>

PowerShell, 94 ไบต์

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

(As a single line)

ไม่มีอะไรที่ฉลาดเกินไปเกี่ยวกับเรื่องนี้ แต่การใช้ piping sort -U[nique]เป็นวิธีที่เรียบร้อยในการใช้งาน Ape Python set()สำหรับการใช้งานประเภทนี้โดยไม่ต้องเพิ่มรายการลงใน hashtable อย่างชัดเจน

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

gawk 4, 73 + 5 สำหรับค่าสถานะ = 78 bytes

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

ทุกบาท0bis 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 35853 37176 37905 38772 39147 39336 6 6 6 6 6 6 6 6 6 4 5 6 6 6 7 4 4 5 7 8 9 8 9 8 9 10 9 10 9 10 9 10 12 12 14 14 14 14 9662 9662 68781 69513 71433 72621 75759 76047 76182 77346 78072 78453 80361 80445 81222 81945 83919 84619 8546 858586 89023 89023 89023 89023 89023 90909 9090
3: 69 128 203 302 327 366 398 467 542 591 593 598 633 643 669 690 747 759 903 923 943 1016 1018 1027 1028 1043 1086 1186 1182 1194 1278 1280 1282 1278 1280 1282 1278 1280 1282 1278 1280 1280 1509 1519 1563 1569 1599 1602 1603 1618 1631 1633 1634 1659 1669 1687 1701 1712 1721 1737 1746 1746 1767 1778 1780 1780 1791 2337 1844 1869 1889 2496 2499 2460 2462 2468 2462 2462 2468 2462 2053 2075 2123 2126 2134 2157 2158 2159 2168 2175 2183
4: 18 54 59 67 71 84 93 95 97 108 112 132 132 139 144 148 148 156 157 159 169 172 174 178 179 180 181 182 184 195 196 213 214 214 215 216 221 223 227 228 2223 2323 241 242 248 265 266 267 270 272 273 279 281 285 287 294 298 299 306 311 312 314 315 316 323 326 329 332 336 338 332 343 353 354 356 351 364 369 369 369 369 369 369 369 399 399 396 397 393 396 397 393 396 397 396 397 396 397 396 431 434 439 442 443 444 448 451 452 453 454 455 457 459 453 466 469 469 472 473 477 479 472 484 486 489 483 494 496 503 507 508 509 515 517 523 523 523 523 523
5: 8 16 19 27 28 38 44 47 55 57 61 77 79 80 82 83 86 87 91 92 103 106 113 116 117 118 121 123 125 126 129 131 133 136 138 140 141 142 143 145 146 151 154 160 165 167 173 175 176 177 183 185 185 187 189 191 192 193 197 198 204 207 218 224 226 229 230 231 236 240 243 246 243 246 253 255 257 258 259 261 263 268 279 277 278 278 278 279 278 278 289 288 289 293 304 309 322 328 331 339 341 344 345 346 347 348 359 352 357 359 367 371 372 373 374 373 375 377 375 383 384 387 389 402 407 404 411 417 418 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 114 120 120 127 130 134 137 149 153 155 162 164 166 168 170 194 199 206 211 212 217 219 220 222 225 233 237 238 244 247 252 254 256 262 264 274 291 295 296 2930 301 308 317 311 324 325 330 333 334 337 33 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 401 404 405 406 415 420 421 424 425 429 430 433 435 438 446 450 460 471 476 478 488 490 498 502 504 506 505 505 510 513 514 519 548 556 578 620 628 631 634 636 636
7: 7 11 14 17 29 31 32 35 41 48 52 56 63 64 70 74 85 89 96 99 102 104 110 111 135 171 188 201 202 205 208 251 290 297 303 305 307 310 313 318 320 335 350 363 392 410 465 475 480 483 485 501 511 518 520 521 560 582 584 595 601 630 640 682 700 736 740 786 798 850 890 952 956 965 975 975 982 990 999 1002 1011 1020 1040 1054 1100 1110 1371 1319 1313 1331 1313 13,513 13 13 13 13 13 14 13 14 13 14 14 14 14 14 14 14 14 14 14 14 16 พระราชินี 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 1004 1240 2002 2090 2100 2500 2600 2975 3000 3400 3944 4376 5050 6500 6885 7399 10040 12400 15483 20002 20020 20900 21000 25000 26000 29750 30000 34000 43760 73990 
9: 15 68 101 150 1001 1010 1,500 1,0001 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