Theo trang Wikipedia về số 69 , cần lưu ý rằng 69 ² = 4.761 và 69 ³ = 328.509 cùng sử dụng tất cả các chữ số thập phân. Số 69 trên thực tế là số thấp nhất thỏa mãn tính chất này.

Vì một lý do tương tự, 32.043 là đáng chú ý: 32.043 ² = 1.026.753.849 sử dụng tất cả các chữ số thập phân.

Nếu chúng ta sẽ tiếp tục nói về những con số thú vị theo cách này, chúng ta sẽ cần một số ký hiệu.

Đối với hầu hết các số nguyên n , lũy thừa n ² , chụp, n ^k sẽ sử dụng tất cả mười chữ số thập phân (không tính các số 0 đứng đầu) ít nhất một lần cho các giá trị k đủ lớn . Nếu nó tồn tại, chúng ta sẽ gọi k thấp nhất như vậy là CUDDLE ( Số thập phân thập phân tích lũy, số mũ nhỏ nhất ) của n .

Bài tập

Viết chương trình hoặc hàm chấp nhận một số nguyên n không âm duy nhất làm đầu vào và tính toán và trả về CUDDLE của nó .

Nếu n không có CUDDLE , bạn có thể trả về bất cứ thứ gì ngoại trừ một số nguyên dương, bao gồm một lỗi hoặc một chuỗi trống, miễn là cuối cùng mã của bạn dừng lại.

Các trường hợp thử nghiệm

Cột bên trái là đầu vào, cột bên phải là đầu ra.

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

Quy tắc bổ sung

• Mã của bạn phải hoạt động cho tất cả các đầu vào lên tới 255 .

  Lưu ý rằng điều này liên quan đến việc xử lý số lượng khá lớn. 20 ¹⁵ đã lớn hơn 2 ⁶⁴ .

• Nếu bạn in kết quả, nó có thể được theo sau bởi một nguồn cấp dữ liệu.

• Luật golf tiêu chuẩn được áp dụng.

Bình thường, 16 byte

hf<9l{=+k^QTtS15

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giống như các giải pháp khác, tôi sử dụng 15 như một giới hạn trên. Tôi tin rằng đây cũng là CUDDLE tối đa . Tôi đã kiểm tra tất cả các số lên tới 10.000.000 và không có số nào có CUDDLE lớn hơn 15.

Các số có CUDDLE > = 10 đã khá hiếm. Các số duy nhất có CUDDLE là 15 là các số 2*10^k. Không có số nào có CUDDLE 14 hoặc 13, CUDDLE 12 chỉ xuất hiện cho các số 6*10^k, CUDDLE 11 chỉ dành cho 5*10^k.

Vì vậy, tôi nghĩ rằng mã này hoạt động hoàn hảo cho bất kỳ số tự nhiên.

In một thông báo lỗi, nếu không có giải pháp.

Giải trình:

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)

Con trăn 2, 56

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

Một giải pháp đệ quy. Đếm số mũ ibắt đầu từ 2và tích lũy các chữ số của lũy thừa n**ivào chuỗi s. Khi scó tất cả mười chữ số, trả về True, bằng 1, và nếu không thì đệ quy và thêm 1. Điều này hóa ra ngắn hơn trở về i.

Gọi hàm trên một số không có CUDDLE kết thúc bằng Internal error: RangeError: Maximum call stack size exceeded. Các số lên đến 255mức đó không bao giờ cần nhiều hơn 15 lần lặp.

Do thói quen khó chịu của Python 2 khi nối thêm Lsố lớn, chúng tôi thực sự khởi tạo chuỗi chữ số thành Lvà kiểm tra xem kích thước đã đặt ít nhất là 11. Python 3 lưu 2 ký tự bằng cách không cần điều này, nhưng mất 3 ký tự khi sử dụng strqua backticks. Python 3.5 tiết kiệm thêm 2 ký tự với bộ giải nén, lưu tổng số char trên Python 2:

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

Ruby, 67 65 ký tự

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

Hoạt động gần như ngay lập tức cho tất cả các trường hợp thử nghiệm, ngay cả những trường hợp> 255.

Lỗi cho các số không có CUDDLE.

Giải trình:

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

Dùng thử trực tuyến

Điều này phụ thuộc vào thực tế là CUDDLE (nếu nó tồn tại) không bao giờ lớn hơn 15 cho phạm vi đầu vào, như lần đầu tiên được quan sát bởi @xnor.

Có lẽ có một cách tốt hơn để sản xuất đầu ra cho trường hợp không có giải pháp. Tôi sẽ cập nhật nếu tôi nghĩ bất cứ điều gì.

Giải trình:

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.

Toán học, 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])&

Dường như chỉ có 10 sức mạnh cuối cùng sẽ không có CUDDLE, vì vậy chúng bị bỏ qua. Hàm giữ một danh sách các chữ số nhìn thấy và dừng lại khi không còn số không trong đó.

Đầu ra:

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

Không tệ cho một ngôn ngữ được giới hạn ở số nguyên 53 bit.

Kiểm tra chạy đoạn mã dưới đây trong trình duyệt thực hiện EcmaScripts 6, bao gồm các chức năng mũi tên và toán tử trải rộng (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)

Không có gì quá thông minh về điều đó, nhưng đường ống sort -U[nique]là một cách gọn gàng để thực hiện set()chức năng của Python cho loại sử dụng này, mà không thêm các mục vào hashtable một cách rõ ràng.

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

ví dụ

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 cho cờ = 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:_

Đối với mỗi chữ số 0bis 9nó gặp trong quyền hạn của đầu vào, nó đặt bit đại diện 2^digittrong a, cho đến khi 10 chữ số đầu tiên được tìm thấy ( a == 1023 == 2^10-1) hoặc có Đã hơn 15 lần lặp lại.

Phải được gọi với một bộ tách trường trống và cờ -M cho số lớn.

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=

Loay hoay với điều này, tôi đã tìm thấy các trình tự sau đây cho các CUDDLE khác nhau:

1, 3944 Số 6, 6
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 1112 1182 1194 1199 1233 1278 1280 1282 1328 1336 1364 1396 14 14 14 14 14 14 14 14 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 1869 1889 1895 1899 1903 1919 1921 1936 1956 1919 1919 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 156 157 159 169 172 174 178 179 180 181 182 184 195 196 213 214 215 216 221 223 227 228 232 234 235 239 241 242 248 265 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 342 343 353 354 356 361 362 364 365 369 369 379 388 391 393 395 396 397 403 412 413 414 416 419 423 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 103 106 113 116 117 118 121 123 125 126 129 131 133 136 138 140 141 143 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 229 230 231 236 240 243 246 249 255 255 256 259 259 261 263 269 269 271 275 276 277 278 280 282 283 288 288 288 288 293 304 309 322 328 331 339 341 344 345 346 347 349 349 352 357 359 367 371 372 373 374 375 377 380 381 384 387 389 402 407 408 409 411 417 418 422
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 237 238 244 247 252 254 256 262 264 274 291 295 296 301 308 317 319 321 324 325 330 333 334 337 351 355 358 360 370 376 378 382 383 385 386 390 394 399 401 404 405 406 415 420 421 424 425 429 430 433 435 438 446 450 450 460 471 476 478 488 490 498 502 504 506 510 513 514 519 530 539 548 556 578 620
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 245 251 290 297 303 304 307 310 313 318 320 335 350 363 392 410 465 464 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 43750 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