给定一个半素数 N，找到最小的正整数m，这样就可以在N * m的二进制表示形式中找到N的两个因子之一的二进制表示形式。

例

让我们考虑半素数N = 9799。

我们尝试从1开始的m的不同值：

 m |  N * m |   N * m in binary
---+--------+------------------
 1 |   9799 |    10011001000111
 2 |  19598 |   100110010001110
 3 |  29397 |   111001011010101
 4 |  39196 |  1001100100011100
 5 |  48995 |  1011111101100011
 6 |  58794 |  1110010110101010
 7 |  68593 | 10000101111110001
 8 |  78392 | 10011001000111000
 9 |  88191 | 10101100001111111
10 |  97990 | 10111111011000110
11 | 107789 | 11010010100001101

我们在这里停止，因为最后一个乘积101001的二进制表示包含41的二进制表示，这是9799的两个因子之一（另一个是239）。

因此答案将是11。

规则和注意事项

• 甚至尝试m的值是没有意义的。为了完整起见，在上面的示例中显示了它们。
• 你的程序必须支持任何ň针对牛顿·米是你的语言的计算能力范围之内。
• 您可以事先分解N，而不用尝试N * m的二进制表示形式的每个可能的子字符串，看看它是否真是N的因数。
• 如MitchellSpector所证明，m始终存在。
• 这是代码高尔夫球，因此最短的答案以字节为单位。禁止出现标准漏洞。

测试用例

第一列是输入。第二列是预期的输出。

         N |    m |         N * m |                              N * m in binary | Factor
-----------+------+---------------+----------------------------------------------+-------
         9 |    3 |            27 |                                      [11]011 |      3
        15 |    1 |            15 |                                       [11]11 |      3
        49 |    5 |           245 |                                   [111]10101 |      7
        91 |    1 |            91 |                                    10[1101]1 |     13
       961 |   17 |         16337 |                             [11111]111010001 |     31
      1829 |    5 |          9145 |                             1000[111011]1001 |     59
      9799 |   11 |        107789 |                          1[101001]0100001101 |     41
     19951 |   41 |        817991 |                       1[1000111]101101000111 |     71
    120797 |   27 |       3261519 |                     11000[1110001]0001001111 |    113
   1720861 |  121 |     208224181 |               11000110100[100111111101]10101 |   2557
 444309323 |  743 |  330121826989 |    100110011011100110010[1101010010101011]01 |  54443
 840000701 | 4515 | 3792603165015 | 11011100110000[1000110000111011]000101010111 |  35899
1468255967 |   55 |   80754078185 |      1001011001101010100010[1110001111]01001 |    911

Pyth，13个字节

ff}.BY.B*TQPQ

示范

说明：

ff}.BY.B*TQPQ
f                Find the first integer >= to 1 where the following is true
 f         PQ    Filter the prime factors of the input
        *TQ      Multiply the input by the outer integer
      .B         Convert to a binary string
   .BY           Convert the prime factor to a binary string
  }              Check whether the factor string is in the multiple string.

05AB1E，18 16 15字节

-2个字节感谢赖利！

-1字节感谢Emigna！

[N¹*b¹Ñ¦¨båOiNq

说明：

[                   # Infinite loop start
 N                  # Push the amount of times we have iterated
  ¹*               # Multiplied by input
    b              # Convert to binary
     ¹Ñ¦¨b         # Calculate the proper divisors of the input in binary excluding one
          åO       # Check if a substring of N * m in binary is in the divisors
            iNq    # If so, print how many times we have iterated and terminate the program

在线尝试！

JavaScript（ES6），96 95 80字节

n=>F=m=>(k=p=>p&&(q=1,g=x=>1<x&&x<n&n%x<1|g(x>>1,q*=2))(p)|k(p-q))(n*m)?m:F(-~m)

返回使用递归函数的递归函数的函数，该递归函数使用递归函数。我真的开始怀疑这.toString(2)条路线会不会更短...

分配给变量，例如，f=n=>...并使用一对额外的括号调用f(9)()。如果不允许这样做（元发布位于+ 6 / -2），则可以将此83字节版本与标准调用一起使用：

f=(n,m)=>(k=p=>p&&(q=1,g=x=>1<x&&x<n&n%x<1|g(x>>1,q*=2))(p)|k(p-q))(n*m)?m:f(n,-~m)

除最后三个测试用例外，这两个版本均适用。您也可以通过更改x>>1为来尝试这些测试用例(x-x%2)/2。

Bash + Unix实用程序，85 84字节

for((;;m++)){ dc -e2o$[$1*m]n|egrep -q $(dc "-e2o`factor $1`nBEPn")&&break;}
echo $m

在线尝试！

我还要指出，对于任何半素数n来说m始终存在。原因如下：

写n = pq，其中p和q是素数，p <= q。

令b以n-1的二进制表示形式的位数。然后，对于介于0和n-1之间（含0和n-1）的任何k，二进制中的p *（2 ^ b）+ k由p的二进制表示组成，后跟b个表示k的附加位。

因此，对于0 <= k <= n-1的数字p *（2 ^ b）+ k，当以二进制形式编写时，均以p的二进制表示形式开头。但是这些是n个连续的数字，因此其中之一必须是n的倍数。

因此，我们有n的倍数mn，其二进制表示形式以p的二进制表示形式开头。

基于此，可以得出m为2 sqrt（n）的上限。（一个上限可能比这更严格。）

Haskell，161字节

import Data.List
(!)=mod
a#b|a!b==0=b|0<1=a#(b+1)
g 0=[]
g n=g(n`div`2)++show(n!2)
(a%b)c|g b`isInfixOf`g(a*c)=c|0<1=a%b$c+1
f n=min(n%(n#2)$1)$n%(n`div`(n#2))$1

直接检查。首先分解因子，然后从1开始线性搜索，并取两个因子的最小值。

最后一个测试用例（1468255967）花费几秒钟，在笔记本电脑上ghci报告(15.34 secs, 18,610,214,160 bytes)。

Mathematica，83个字节

1//.x_/;FreeQ[Fold[#+##&]/@Subsequences@IntegerDigits[x#,2],d_/;1<d<#&&d∣#]:>x+1&

Brachylog（2），14个字节

ḋḃᵐD∧?:.×ḃs∈D∧

在线尝试！

在Brachylog中用14个字节编写此内容的方法不只一种，所以我选择了最有效的方法。与Brachylog提交一样，这是一个功能提交。它的输入是半素数，其输出是乘数。

说明

ḋḃᵐD∧?:.×ḃs∈D∧
ḋ               Prime decomposition (finds the two prime factors)
 ḃᵐ             Convert each factor to binary
   D            Name this value as D
    ∧?          Restart with the user input
      :.×       The output is something that can be multiplied by it
         ḃ      to produce a number which, when expressed in binary
          s     has a substring
           ∈D   that is an element of D
             ∧  (suppress an implicit constraint that D is the output; it isn't)

Prolog和Brachylog的评估顺序由无法立即从输入中推导出的第一个约束条件设置。在此程序中，这是对乘法结果的约束，因此解释器将力争使乘法的操作数尽可能接近0。我们知道其中一个操作数，另一个是输出，因此我们找到了可以达到的最小输出，这正是我们想要的。

PowerShell，136字节

param($n)$a=2..($n-1)|?{!($n%$_)}|%{[convert]::ToString($_,2)};for(){$b=[convert]::toString(++$m*$n,2);if($a|?{$b-like"*$_*"}){$m;exit}}

在线尝试！

由于在PowerShell中转换为二进制的方式非常冗长。：-/

接受输入$n，循环遍历2到$n-1翻出的因素!($n%$_)。将它们发送到循环中，|%{...}并将convert每个发送到二进制（基本2）字符串。将这些二进制字符串存储到中$a。

然后我们进入无限for(){...}循环。每次迭代，我们递增++$m，乘以$n，然后乘以convert一个二进制字符串，存储到中$b。然后，if该字符串是正则表达式中的-like任何字符串$a，我们输出$m和exit。

Perl 6 6，66个字节

->\n{first {(n*$_).base(2)~~/@(grep(n%%*,2..^n)».base(2))/},^∞}

基于正则表达式。

超级慢，因为它强行破坏了以下因素 在尝试的每个数字的每个正则表达式匹配位置上都再次遍历n个。

仅计算一次因子，可以提高性能，但使其成为72个字节：

->\n{my @f=grep(n%%*,2..^n)».base(2);first {(n*$_).base(2)~~/@f/},^∞}