Menurut halaman Wikipedia pada angka 69 , dapat dicatat bahwa 69 ² = 4.761 dan 69 ³ = 328.509 bersama-sama menggunakan semua angka desimal. Angka 69 sebenarnya adalah angka terendah yang memuaskan properti ini.

Untuk alasan yang sama, 32.043 luar biasa: 32.043 ² = 1.026.753.849 menggunakan semua angka desimal.

Jika kita akan terus berbicara tentang angka yang menarik dengan cara ini, kita perlu beberapa notasi.

Untuk sebagian besar bilangan bulat n , pangkat n ² , ..., n ^k akan menggunakan semua sepuluh angka desimal (tidak termasuk angka nol terkemuka) setidaknya satu kali untuk nilai k yang cukup besar . Jika ada, kami akan memanggil terendah seperti k yang CUDDLE ( kumulatif Decimal Digit, Least Eksponen ) dari n .

Tugas

Tulis program atau fungsi yang menerima satu bilangan bulat non-negatif n sebagai input dan menghitung serta mengembalikan CUDDLE - nya .

Jika n tidak memiliki CUDDLE , Anda dapat mengembalikan apa pun kecuali bilangan bulat positif, termasuk kesalahan atau string kosong, selama kode Anda akhirnya berhenti.

Uji kasus

Kolom kiri adalah input, kolom kanan adalah output.

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

Aturan tambahan

• Kode Anda harus bekerja untuk semua input hingga 255 .

  Perhatikan bahwa ini melibatkan berurusan dengan angka yang cukup besar. 20 ¹⁵ sudah lebih besar dari 2 ⁶⁴ .

• Jika Anda mencetak hasilnya, itu mungkin diikuti oleh linefeed.

• Aturan standar kode-golf berlaku.

Pyth, 16 byte

hf<9l{=+k^QTtS15

Cobalah online: Demonstrasi atau Test Suite

Seperti solusi lain, saya menggunakan 15 sebagai batas atas. Saya percaya bahwa ini juga CUDDLE maksimal . Saya menguji semua angka hingga 10.000.000, dan tidak ada angka dengan CUDDLE lebih besar dari 15.

Angka dengan CUDDLE > = 10 sudah sangat jarang. Satu-satunya angka dengan CUDDLE 15 adalah angka 2*10^k. Tidak ada angka dengan CUDDLE 14 atau 13, CUDDLE 12 hanya muncul untuk angka 6*10^k, CUDDLE 11 hanya untuk 5*10^k.

Jadi saya pikir kode ini berfungsi dengan baik untuk setiap nomor alami.

Mencetak pesan kesalahan, jika tidak ada solusi.

Penjelasan:

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`)

Solusi rekursif. Menghitung eksponen imulai dari 2dan mengakumulasi digit kekuatan n**ike dalam string s. Ketika smemiliki semua sepuluh digit, pengembalian True, yang sama dengan 1, dan jika tidak berulang dan menambah 1. Ini ternyata lebih pendek daripada kembali i.

Memanggil fungsi pada nomor tanpa CUDDLE berakhir dengan Internal error: RangeError: Maximum call stack size exceeded. Angka hingga 255yang melakukan output tidak perlu lebih dari 15 iterasi.

Karena kebiasaan Python 2 yang mengganggu menambahkan sejumlah Lbesar, kita benar-benar menginisialisasi string digit ke Ldan memeriksa apakah ukuran yang ditetapkan setidaknya 11. Python 3 menyimpan 2 karakter dengan tidak membutuhkan ini, tetapi kehilangan 3 karakter pada penggunaan strbackticks yang berlebihan. Python 3.5 menyimpan 2 karakter lagi dengan set unpacking, menghemat char di atas Python 2 secara total:

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

Ruby, 67 65 karakter

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

Bekerja dekat-instan untuk semua kasus uji, bahkan yang> 255.

Kesalahan untuk nomor tanpa CUDDLE.

Penjelasan:

-> 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 byte

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

Cobalah online

Ini bergantung pada fakta bahwa CUDDLE (jika ada) tidak pernah lebih besar dari 15 untuk rentang input, seperti yang pertama kali diamati oleh @xnor.

Mungkin ada cara yang lebih baik untuk menghasilkan output untuk kasus di mana tidak ada solusi. Saya akan memperbarui jika saya memikirkan sesuatu.

Penjelasan:

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 byte

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

Tampaknya hanya kekuatan 10 yang pada akhirnya tidak akan memiliki CUDDLE, jadi mereka dilewati. Fungsi menyimpan daftar angka yang terlihat dan berhenti ketika tidak ada lagi nol di dalamnya.

Keluaran:

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

Tidak buruk untuk bahasa yang terbatas pada integer 53 bit.

Tes menjalankan cuplikan di bawah ini di peramban yang mengimplementasikan EcmaScripts 6, termasuk fungsi panah dan operator sebar (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 byte

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

(As a single line)

Tidak ada yang terlalu pintar tentang hal itu, tetapi perpipaan ke sort -U[nique]adalah cara yang rapi untuk meningkatkan set()fungsionalitas Python untuk penggunaan seperti ini, tanpa secara eksplisit menambahkan item ke 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).

misalnya

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 untuk flags = 78 byte

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

Untuk setiap digit 0bis 9itu bertemu dalam kekuasaan input, ia menetapkan bit yang mewakili 2^digitdi a, sampai pertama 10 digit ditemukan ( a == 1023 == 2^10-1) atau sudah ada lebih dari 15 iterasi.

Harus dipanggil dengan pemisah bidang kosong dan bendera -M untuk angka besar.

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=

Mengutak-atik ini, saya menemukan urutan berikut untuk CUDDLE yang berbeda:

2: 3203.312 di mana. 68781 69513 71433 72621 75759 76047 76182 77346 78072 78453 80361 80445 81222 81945 83919 84648 85353 85743 85803 86073 87639 88623 89079 8914890149 9014 94909599595
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 1027 1028 1027 1028 1012 1032 1278 1280 1280 1282 1328 1336 1364 1364 1509 1519 1563 1569 1599 1602 1603 1618 1631 1633 1634 1659 1669 1687 1701 1712 1721 1737 1746 1767 1774 1778 1780 1791 1804 1837 1844 1844 1844 1889 1895 1899 1903 1919 1921 1936 1956 1958 1960 1962 1973 1984 1985 1991 1991 2053 2075 2123 2126 2134 2157 2158 2159 2168 2175 2183
4: 18 54 59 67 71 84 93 95 97 108 112 115 132 139 144 147 148 152 157 159 172 172 178 179 180 181 182 184 195 196 213 214 215 221 221 227 227 232 234 239 239 241 241 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 348 342 343 353 356 366 368 369 369 369 369 368 368 398 397 393 412 413 416 426 431 434 439 442 443 444 448 451 452 453 454 455 457 459 463 466 469 472 473 477 479 482 484 486 489 493 494 496 503 507 508 509 515 517 523
5: 8 16 19 27 28 38 44 47 55 57 61 77 79 80 82 83 86 87 91 92 106 106 116 117 118 121 123 125 126 129 131 133 136 138 140 141 142 143 145 146 151 154 158 160 161 165 167 173 175 176 177 183 185 186 187 189 190 191 192 193 197 198 204 207 218 224 226 230 230 236 236 243 243 249 253 255 257 258 259 261 263 268 269 271 275 276 277 278 280 282 284 286 288 289 292 293 304 309 322 328 331 339 341 344 345 346 347 348 349 352 357 359 367 371 372 373 374 375 377 380 381 384 387 389 402 407 408 409 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 119 120 122 127 130 134 137 149 153 155 162 163 164 166 168 170 194 199 206 211 212 217 219 220 222 225 233 238 238 244 247 247 254 256 262 264 274 291 295 296 301 308 317 319 321 323 325 330 333 334 337 357 357 358 388 382 383 385 386 390 394 399 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 510 513 514 530 59 538 548 556 578 620 628 631 636
7: 7 11 14 17 29 31 32 35 41 48 52 56 63 64 70 74 85 89 96 99 110 110 135 135 188 201 202 205 208 245 251 290 297 303 305 307 310 313 318 313 318 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 982 990 1009 1005 1011 1020 1040 1054 1100 1110 1171 1219 1313 1331 1347 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 50500 6585050 73990 
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