给定一个从1到24的数字，请根据目前的知识输出接吻数字（某些数字会有一个以上的可接受输出）。几何知识不是必不可少的，因为下面列出了所有输出。

从Wikipedia页面上的Kissing Number问题：

接吻数定义为不重叠的单位球的数量，可以将它们排列成每个都接触另一个给定的单位球

也就是说，给定一个单位球，在没有任何单位球重叠的情况下，还有多少个单位球可以接触它？该问题将在N维空间中提出，其中一个球体被理解为N-1维球体。

例如：

• 在二维空间中，一个单位圆可以触摸其他6个单位圆。
• 在3维空间中，一个单位球可以接触其他12个单位球。

Wikipedia页面列出了1到24维空间的值。但是，其中一些尚不准确，因此仅给出了下限和上限。在此复制该表，以便无论将来由于新的证明而缩小范围，该表都将保持不变。即使将来修改了Wikipedia页面，也将根据此固定表来判断解决方案。

界限表

Dimension   Lower bound     Upper bound
1           2               2
2           6               6
3           12              12
4           24              24
5           40              44
6           72              78
7           126             134
8           240             240
9           306             364
10          500             554
11          582             870
12          840             1357
13          1154            2069
14          1606            3183
15          2564            4866
16          4320            7355
17          5346            11072
18          7398            16572
19          10668           24812
20          17400           36764
21          27720           54584
22          49896           82340
23          93150           124416
24          196560          196560

输入项

维度：1到24（含）之间的整数。

此处的“整数”表示输入将没有小数部分-可能是2，3但永远不会2.5。例如，解决方案仍可以将输入作为浮点数或字符串。

输出量

相关范围内的数字，从该输入的下限到上限（包括该上限）。

输出必须是确定性的（对于相同的输入始终相同）。

输出必须是整数。例如，对于输入5的可能的有效输出40，41，42，43，44。请注意，这是对值的限制，而不是类型。如果浮点数的小数部分为零，则可以返回浮点数。例如，41.5将无效，但41.0将有效。

计分

这是代码高尔夫球。您的分数是代码中的字节数。对于每种语言，赢家都是得分最低的解决方案。

朱莉娅0.6，52字节

n->ceil(n<8?3.7exp(.51n)-5.1:n<24?9exp(.41n):196560)

在线尝试！

怎么样？

机器学习！（金田。也许。不是。）

首先，通过针对N绘制上下限数据以及一些手动试验和错误，似乎指数函数可以很好地适合N> =8。在尝试手动找到该函数之后，我求助于使用一个参数调整函数以调整 （其中K = 8至24）以找到a，b和c，使得表达式给出的值位于每个K的正确范围内（可能值的范围逐渐减小）并在函数的不同运行中相应提高a，b，c的精度）。有一些这样的值集，尽管它们都不能完全适合N = 24的情况，因此我选择了一个值为0 的值并将其硬编码为N = 24。$a * e^{b K} + c$c

对于较低的N，从1到7，我希望找到一些更简单的表达式或多项式，但找不到适合的表达式。因此，回到拟合，这次是K = 1到7（尽管根据视觉图的趋势，我并不认为指数在这种情况下是正确的拟合）。值得庆幸的是，这里有参数a，b，c可以给出整个范围内的正确值（至少在一次调用中）。$a * e^{b K} + c$ceil

86，62个 59 53 50字节

我的解决方案使用字节查找表并将其移位2（不进行FP计算）。尺寸9至23为变速提供了足够的回旋余地。输入eax和输出ecx。

-3通过交换eax，ecx因为cmp $imm, %al比短cmp $imm, %cl。

-4通过不单独处理N = 24情况，而是将调整应用于所有1024个情况。

-2通过不早返回（愚蠢）

-3通过使用表作为偏移量，movzbl而不是用xor

start:
        dec     %eax                # 1-indexed table

        movzbl  table(%eax), %ecx   # return byte directly
        cmp     $8, %al
        jl      exit

        sal     $6, %ecx            # * 64 
        cmp     $19, %al
        jl      exit

        sal     $4, %ecx            # * 16
        sub     $48, %ecx

exit:   
        ret

#.data
table:  .byte   2, 6, 12, 24, 40, 72, 126, 240              # * 1
        .byte   5, 8, 10, 14, 19, 26, 41, 68, 84, 116, 167  # * 64  
        .byte   18, 28, 49, 92, 192                         # * 1024 - 48

十六进制转储（用.text代替的表.data）

00000502  48 0f b6 88 1c 05 00 00  3c 08 7c 0d c1 e1 06 3c  |H.......<.|....<|
00000512  13 7c 06 c1 e1 04 83 e9  30 c3 02 06 0c 18 28 48  |.|......0.....(H|
00000522  7e f0 05 08 0a 0e 13 1a  29 44 54 74 a7 12 1c 31  |~.......)DTt...1|
00000532  5c c0                                             |\.|

JavaScript（ES6），60个字节

f=(n,k=2)=>n<24?--n?f(n,k*24/(17+~'_8443223'[n])):~~k:196560

在线尝试！

怎么样？

$a_{24}=196560$

所有其他项均使用以下方法递归计算：

$$\begin{cases}a_1=2\\a_{n+1}=a_n\times\dfrac{24}{q_n}\end{cases}$$

$q_n$

$$\begin{cases}q_1=8\\q_2=12\\q_3=12\\q_4=13\\q_5=14\\q_6=14\\q_7=13\\q_n=16,&\text{for }n>7\end{cases}$$

导致以下比率：

$$3,2,2,\frac{24}{13},\frac{12}{7},\frac{12}{7},\frac{24}{13},\frac{3}{2},\frac{3}{2},\ldots,\frac{3}{2}$$

最终结果最终会落空并返回。

结果汇总

近似结果以小数点后两位表示。

  n |   a(n-1) | multiplier |      a(n) | output |          expected
----+----------+------------+-----------+--------+-------------------
  1 |      n/a |        n/a |         2 |      2 |                2
----+----------+------------+-----------+--------+-------------------
  2 |        2 |          3 |         6 |      6 |                6
  3 |        6 |          2 |        12 |     12 |               12
  4 |       12 |          2 |        24 |     24 |               24
  5 |       24 |      24/13 |     44.31 |     44 |        [40,..,44]
  6 |    44.31 |       12/7 |     75.96 |     75 |        [72,..,78]
  7 |    75.96 |       12/7 |    130.21 |    130 |      [126,..,134]
  8 |   130.21 |      24/13 |    240.39 |    240 |              240
  9 |   240.39 |        3/2 |    360.58 |    360 |      [306,..,364]
 10 |   360.58 |        3/2 |    540.87 |    540 |      [500,..,554]
 11 |   540.87 |        3/2 |    811.31 |    811 |      [582,..,870]
 12 |   811.31 |        3/2 |   1216.97 |   1216 |     [840,..,1357]
 13 |  1216.97 |        3/2 |   1825.45 |   1825 |    [1154,..,2069]
 14 |  1825.45 |        3/2 |   2738.17 |   2738 |    [1606,..,3183]
 15 |  2738.17 |        3/2 |   4107.26 |   4107 |    [2564,..,4866]
 16 |  4107.26 |        3/2 |   6160.89 |   6160 |    [4320,..,7355]
 17 |  6160.89 |        3/2 |   9241.34 |   9241 |   [5346,..,11072]
 18 |  9241.34 |        3/2 |  13862.00 |  13862 |   [7398,..,16572]
 19 | 13862.00 |        3/2 |  20793.01 |  20793 |  [10668,..,24812]
 20 | 20793.01 |        3/2 |  31189.51 |  31189 |  [17400,..,36764]
 21 | 31189.51 |        3/2 |  46784.26 |  46784 |  [27720,..,54584]
 22 | 46784.26 |        3/2 |  70176.40 |  70176 |  [49896,..,82340]
 23 | 70176.40 |        3/2 | 105264.59 | 105264 | [93150,..,124416]
----+----------+------------+-----------+--------+-------------------
 24 |           (hard-coded)            | 196560 |           196560 

果冻，29 26字节

“~D=ⱮziEc+y’Dḣ+⁵÷7PĊ«“£#;’

在线尝试！

怎么运行的

“~D=ⱮziEc+y’Dḣ+⁵÷7PĊ«“£#;’  Main link. Argument: n

“~D=ⱮziEc+y’                Set the return value to 485523230101001100011122.
            D               Decimal; convert the return value to base 10.
             ḣ              Head; take the first n elements of the digit list.
              +⁵            Add 10 to each element.
                ÷7          Divide the sums by 7.
                  P         Take the product.
                   Ċ        Ceil; round up to the nearest integer.
                     “£#;’  Yield 196560.
                    «       Take the minimum.

JavaScript（Node.js），120 99字节

丢弃21个字节。由于tsh的建议，在数组的开头增加了一个孔（节省了从n-1到的两个字节n，并针对上下限内的舍入数，从而将它们从定点表示法缩小1154为指数表示法，从而大大减少了）喜欢2e3。

同样，我的最初目标是展示“哑巴”方式的轻巧程度（例如，不使用任何真实的数学方法，例如Arnauld的答案。令人印象深刻的是，在没有任何变换或计算的情况下，仍有缩小空间的余地。

n=>[,2,6,12,24,40,72,126,240,306,500,582,840,2e3,2e3,3e3,5e3,6e3,8e3,2e4,2e4,3e4,5e4,1e6,196560][n]

在线尝试！

长度是Arnauld答案的两倍，复杂度为0。

JavaScript（Node.js），129128字节

（-1字节，感谢使用位移位的建议）

f=(n)=>[2,6,12,24,40,72,126,240].concat([5,8,10,14,19,26,41,68,84,116,167].map(x=>x<<6),[17,28,49,91].map(x=>x<<10),196560)[n-1]

在线尝试！

为了满足有趣的需求，我从x86答案中窃取了逻辑，并由此构建了数组。使它长9个字节。但是更有趣。

符文，173个字节

>i:8(?D5X1+1C,*212,+16,+1c2*,+1cX,+Sp3X7+a,*5X1+a,-1+kn$;
      R:c2*(?D4X1+1C,*212,+16,+1c2*,+Sp9*1+:4XY(?Dkn$;
             R`196560`r@;              ;$*C1nk,C1L

（请注意，右下角应计入字节：它们用空格隐式填充。）

TIO的exe 需要此答案依赖的更新（在要求Dennis重建之前，我正在修补其他漏洞）。但是插入一个值（如果第一行的值使用多个字符，请确保在第2行和第3行添加空格）。这是编写所需值的最简单方法：

0-9,a-f  ->  1-15
2Xn+     ->  20+n

在线尝试！

从功能上讲，这是sundar的Julia答案的一部分（但Runic没有用于推e入堆栈的命令（或实际上，任何十进制值），因此需要一个近似值。e小于8的输入的近似值更为精确，因为精度的损失导致值超出了输出的允许范围（例如7将产生125）。Ceil()通过转换为字符然后再转换为数字来完成此操作（对于非常大的值，此操作失败，因此在40k时我将其除以100，再进行转换，然后再乘以100）。

很可能有一定的空间，简化了安排（如运行的入口点上下，低于或找到一种方法来压缩为近似值e），但我很高兴与刚刚能够做计算。

/?D5X1+1C,*212,+16,+1c2*,+1cX,+Sp3X7+a,*5X1+a,-1+kn$;
  R:c2*(?D4X1+1C,*212,+16,+1c2*,+Sp9*1+:4XY(?Dkn$;
\(8:i<   R`196560`r@;              ;$*C1nk,C1L

161个字节。

口译员更新：

有了推入式固定输入读数，Runic现在具有一些数学功能，并且能够将字符串解析为双精度。这将极大地简化此答案，但我将按原样显示它（展示我投入的精力）（我在发布后不久添加了单参数Math函数和字符串解析：我已经使用了Sin / Cos / Tan我的待办事项清单，但未考虑Exp，Abs，Log等，并且字符已用完）。TIO应该在接下来的24-48小时内更新，具体取决于丹尼斯何时看到。

212,+16,+1c2*,+1cX,+1'eA使用此解释器更新将减少为-> 。A弹出一个字符和一个值，并根据弹出的字符（e在这种情况下为is Exp()并Exp(1)返回e）对该值执行Math运算。