拥抱计算

19

根据Wikipedia页面上数字69的记录，请注意69 2 = 4,761和69 3 = 328,509一起使用所有十进制数字。数字69实际上是满足该属性的最低数字。

出于类似的原因，32,043是卓越的：32,043 2 = 1,026,753,849使用所有十进制数字。

如果我们要继续谈论以这种方式有趣的数字，则需要一些符号。

对于大多数整数ñ，权力ñ 2，...，ñ ķ将使用所有十个十进制数字至少（不包括前导零）一次的足够大的值ķ。如果它存在，我们称之为最低等ķ的卡多（累计十进制数字，最小指数）的ñ。

任务

编写一个接受单个非负整数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 15已经大于2 64。

  • 如果您打印结果，它后面可能会有换行符。

  • 适用标准代码高尔夫球规则。

code-golf  math 
— 丹尼斯
source
14
我想知道我们是如何从CUDDLE升级到69的，我发现它与动力有关有点令人不安；）
— Aaron
如果该数字没有CUDDLE，则程序最终停止可以吗？（即，当整数计数器溢出时）
— 门把手
另外，对于第一个附加规则：这是否意味着如果您语言的整数类型可以存储大于255的数字，则您的代码必须适用于它们？
— 门把手
只要确实停止，@ Doorknob最终还是可以的。我在输入中设置了255的上限。尽管计算中仍然涉及一些相当大的数字……
— 丹尼斯
1
我添加了测试用例，26->8因为这是最小的示例，其中包含n^1给出了错误的答案（of 6），这是我在代码中所犯的错误。
— xnor 2015年

Answers:

4

Pyth，16个字节

hf<9l{=+k^QTtS15

在线尝试：演示或测试套件

像其他解决方案一样，我使用15作为上限。我相信这也是最大的CUDDLE。我测试了所有数字，直到10.000.000，并且没有CUDDLE大于15的数字。

用数字卡多 > = 10已经是相当罕见的。CUDDLE为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)
— 雅库比
source
8

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。

在没有CUDDLE的数字上调用该函数以结尾Internal error: RangeError: Maximum call stack size exceeded。达到255该数字的数字最多不需要重复15次。

由于Python 2烦人的习惯，L在数字后面附加一个，我们实际上将数字字符串初始化为，L并检查设置的大小是否至少为11。Python3通过不需要此字符来节省2个字符，但在使用str反引号时会丢失3个字符。Python 3.5通过设置解压缩节省了2个字符，总共比Python 2节省了一个字符：

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

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
}
— 门把手
source
3

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.
— 雷托·科拉迪（Reto Koradi）
source
2

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
有趣的事实：只要log_10(n)是非理性的，给定正整数k就存在m，使得的十进制表示形式以n^m开头k。这意味着跳过10（和0）的幂是可以的:)
— Sp3000
2

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>
展开摘要

— edc65
source
2

PowerShell，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()一种在不显式地将项目添加到哈希表的情况下，模仿Python这种功能的灵巧方法。

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
— TessellatingHeckler
source
1

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 35853 37176 37905 38772 39147 39336 40545 42744 43902 44016 45567 45624 46587 48852 49314 49353 50706 53976 54976 55446 55524 55581 55626 56532 57321 58413 58455 58554 59554 60984 61984 61575 61866 62679 62961 63051 63129 65634 65637 66105 66276 67677 68781 69513 71433 72621 75759 76047 76182 77346 78072 78453 80361 80445 81222 81945 83919 84648 85353 85743 85803 85073 86073 87639 88623 89079 89145 89355 89523 90144 90153 90198 91248 91605 92214 94695 95154 96702 97779 98055 98802 99066
3：69 128 203 302 327 366 398 467 542 591 593 598 633 633 643 669 690 747 759 903 923 943 1016 1018 1027 1028 1028 1043 1086 1112 1182 1194 1199 1233 1278 1280 1282 1328 1336 1364 1396 14396 119 1459 1463 1467 1472 1475 1484 1499 1508 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 1903 1919 1921 1936 1956 1958 1960 1962 1973 1973 1984 1985 1991 1994 1996 2003 2017 2019 2030 2033 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 152 157 159 169 172 174 178 179 180 181 182 184 195 196 196 213 214 215 216 221 221 223 227 228 232 232 234 235 239 241 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 342 343 353 354 356 361 362 364 365 368 369 379 388 391 393 395 396 397 403 412 413 414 416 419 431 434 439 442 443 444 448 451 452 453 454 455 457 459 463 466 469 472 473 477 479 479 482 484 486 489 493 494 494 496 503 507 508 509 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 136 138 140 141 142 143 145 146 151 154 158 158 160 161 165 167 173175176177183185185186187189189190191192193193197198204204218218224226229230231236240240243246249249255255257258259259261263268268269271271275276277278280280282282284288288289 293 304 309 322 328 331 341 344 345 346 347 348 349 352 357 359 367 371 372 373 374 375 377 380 381 384 387 387 389 402 407 408 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 164 168 168 170194199206211212217217220220222225233237238238244247252254256262264274291291295296301308317319321324325330333334337351351355358360370370376378378383383380390394399 401 404 405 406 415 420 421 424 425 429 430 433 435 438 446 450 460 471 476 478 488 490 498 498 504 504 506 510 513 514 519 519 530 539 548 556 578 620 628 631 634 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 245 251 290 297 303 305 307 310 313 318 320 335 350 363 392 410 465 465 475 480 483 485 485 501 518 520 521 560 582 584 595 601 630 640 682 700 736 740 786 798 850 890 952 956 965 975 982 990 999 1002 1005 1011 1020 1040 1054 1100 1110 1171 1219 1313 1331 1350 1379 1414 1447 1468 160 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 296000 3750 34000 34000 43760 50500 65000 68850 73990 
9：15 68101150 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
— Cabbie407
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.