Cho một bán cầu N , tìm số nguyên dương m nhỏ nhất sao cho biểu diễn nhị phân của một trong hai yếu tố của N có thể được tìm thấy trong biểu diễn nhị phân của N * m .

Thí dụ

Hãy xem xét bán kết N = 9799 .

Chúng tôi thử các giá trị khác nhau của m , bắt đầu từ 1:

 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

Chúng tôi dừng lại ở đây bởi vì đại diện nhị phân của sản phẩm cuối cùng chứa 101001đại diện nhị phân của 41 , một trong hai yếu tố của 9799 (một yếu tố khác là 239 ).

Vì vậy, câu trả lời sẽ là 11 .

Quy tắc và ghi chú

• Cố gắng thậm chí giá trị của m là vô nghĩa. Chúng được thể hiện trong ví dụ trên với mục đích hoàn thiện.
• Chương trình của bạn phải hỗ trợ bất kỳ N nào mà N * m nằm trong khả năng tính toán của ngôn ngữ của bạn.
• Bạn được phép factorize N trước chứ không phải là cố gắng mỗi chuỗi có thể có của các đại diện nhị phân của N * m để xem nếu nó hóa ra là một yếu tố của N .
• Theo chứng minh của MitchellSpector , m luôn tồn tại.
• Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng. Sơ hở tiêu chuẩn bị cấm.

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

Cột đầu tiên là đầu vào. Cột thứ hai là đầu ra dự kiến.

         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

Bình thường, 13 byte

ff}.BY.B*TQPQ

Trình diễn

Giải trình:

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 byte

-2 byte nhờ Riley!

-1 byte nhờ Emigna!

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

Giải trình:

[                   # 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

Hãy thử trực tuyến!

JavaScript (ES6), 96 95 80 byte

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)

Hàm trả về hàm đệ quy sử dụng hàm đệ quy sử dụng hàm đệ quy. Tôi thực sự bắt đầu tự hỏi liệu .toString(2)tuyến đường sẽ ngắn hơn ...

Gán cho một biến, ví dụ f=n=>...và gọi thêm một cặp parens , f(9)(). Nếu điều đó không được phép ( bài meta ở mức + 6 / -2), bạn có thể sử dụng phiên bản 83 byte này với lời gọi tiêu chuẩn:

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)

Cả hai phiên bản đều hoạt động cho tất cả trừ ba trường hợp thử nghiệm cuối cùng. Bạn cũng có thể thử những trường hợp thử nghiệm này bằng cách thay đổix>>1 thành (x-x%2)/2.

Tiện ích Bash + Unix, 85 84 byte

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

Hãy thử trực tuyến!

Tôi cũng sẽ chỉ ra rằng m luôn tồn tại cho bất kỳ bán kết nào. Đây là lý do tại sao:

Viết n = pq, trong đó p và q là số nguyên tố và p <= q.

Đặt b số chữ số trong biểu diễn nhị phân của n-1. Sau đó, với mọi k từ 0 đến n-1, p * (2 ^ b) + k trong nhị phân bao gồm biểu diễn nhị phân của p theo sau là b bit bổ sung đại diện cho k.

Vì vậy, các số p * (2 ^ b) + k với 0 <= k <= n-1, khi được viết dưới dạng nhị phân, tất cả bắt đầu bằng biểu diễn nhị phân của p. Nhưng đây là n số liên tiếp, vì vậy một trong số chúng phải là bội của n.

Theo sau chúng ta có nhiều mn n có biểu diễn nhị phân bắt đầu bằng biểu diễn nhị phân của p.

Dựa trên điều này, người ta có thể đưa ra giới hạn trên cho m là 2 sqrt (n). (Một người có thể có được giới hạn trên chặt chẽ hơn nhiều so với điều này.)

Haskell, 161 byte

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

Kiểm tra đơn giản. Yếu tố đầu tiên, sau đó tìm kiếm tuyến tính bắt đầu từ 1 và lấy giá trị tối thiểu cho cả hai yếu tố.

Mất vài giây cho bản thử nghiệm cuối cùng ( 1468255967), ghcibáo cáo (15.34 secs, 18,610,214,160 bytes)trên máy tính xách tay của tôi.

Toán học, 83 byte

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

Brachylog (2), 14 byte

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

Hãy thử trực tuyến!

Có nhiều hơn một cách để viết điều này trong 14 byte bằng Brachylog, vì vậy tôi đã làm việc hiệu quả nhất. Như thường thấy đối với đệ trình Brachylog, đây là đệ trình chức năng; đầu vào của nó là bán thời gian, đầu ra của nó là cấp số nhân.

Giải trình

ḋḃᵐ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)

Thứ tự đánh giá của Prolog và Brachylog được đặt theo ràng buộc đầu tiên không thể suy ra ngay từ đầu vào. Trong chương trình này, đó là một ràng buộc đối với kết quả của phép nhân, vì vậy trình thông dịch sẽ nhằm mục đích giữ các toán hạng của phép nhân càng gần 0 càng tốt. Chúng tôi biết một trong các toán hạng và cái còn lại là đầu ra, vì vậy chúng tôi tìm đầu ra nhỏ nhất có thể, đó chính xác là những gì chúng tôi muốn.

PowerShell , 136 byte

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

Hãy thử trực tuyến!

Rất dài do cách chuyển đổi thành nhị phân hoạt động trong PowerShell. : - /

Đưa đầu vào $n, vòng lặp 2đến $n-1và rút ra các yếu tố !($n%$_). Gửi chúng vào một vòng lặp |%{...}và converts mỗi trong số chúng đến một chuỗi nhị phân (cơ sở 2). Lưu trữ các chuỗi nhị phân vào $a.

Sau đó, chúng tôi nhập một for(){...}vòng lặp vô hạn . Mỗi lần lặp, chúng ta tăng ++$m, nhân số đó với $nvà convertchuỗi đó thành một chuỗi nhị phân, được lưu trữ vào $b. Sau đó, ifchuỗi đó là regex -likebất kỳ chuỗi nào $a, chúng tôi xuất $mvà exit.

Perl 6 , 66 byte

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

Dựa trên Regex.

Siêu chậm, vì nó vũ phu các yếu tố của n lại xuất hiện ở mọi vị trí khớp chính tả của mọi số được thử.

Chỉ tính toán các yếu tố một lần, cải thiện hiệu suất nhưng làm cho nó 72 byte:

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