กำหนดsemiprime Nค้นหาที่เล็กที่สุดจำนวนเต็มบวกเมตรเช่นที่ฐานเป็นตัวแทนของหนึ่งในสองปัจจัยของNสามารถพบได้ในฐานเป็นตัวแทนของN * เมตร

ตัวอย่าง

ลองพิจารณา semiprime N = 9799

เราลองใช้ค่าต่าง ๆ ของmเริ่มต้นที่ 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

เราหยุดที่นี่เพราะการแสดงเลขฐานสองของผลิตภัณฑ์ล่าสุดมี101001ซึ่งเป็นการแทนเลขฐานสองของ41หนึ่งในสองปัจจัยของ9799 (อีกหนึ่งเป็น239 )

ดังนั้นคำตอบจะเป็น11

กฎและหมายเหตุ

• การลองค่าของmนั้นไม่มีจุดหมาย พวกเขาถูกแสดงไว้ในตัวอย่างข้างต้นเพื่อความสมบูรณ์
• โปรแกรมของคุณต้องรองรับNใด ๆที่N * mอยู่ภายในขีดความสามารถในการคำนวณภาษาของคุณ
• คุณได้รับอนุญาตให้แยกตัวประกอบNล่วงหน้าแทนที่จะลองแต่ละสตริงย่อยที่เป็นไปได้ของการแทนค่าไบนารี่ของN * mเพื่อดูว่ามันจะกลายเป็นปัจจัยของNหรือไม่
• ในฐานะที่ได้รับการพิสูจน์โดย MitchellSpector , มอยู่เสมอ
• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

กรณีทดสอบ

คอลัมน์แรกคืออินพุต คอลัมน์ที่สองคือผลลัพธ์ที่คาดหวัง

         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 ไบต์ขอบคุณ Riley!

-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)()parens, หากไม่ได้รับอนุญาต ( โพสต์เมตาอยู่ที่ + 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

ลองออนไลน์!

ฉันจะชี้ให้เห็นว่า m มีอยู่เสมอสำหรับ semiprime n นี่คือเหตุผล:

เขียน n = pq โดยที่ p และ q เป็นนายกและ p <= q

ให้ b จำนวนหลักในการแทนเลขฐานสองของ n-1 จากนั้นสำหรับ k ใด ๆ ระหว่าง 0 ถึง n-1 ที่รวมอยู่, p * (2 ^ b) + k ในไบนารีประกอบด้วยการแทนค่าฐานสองของ p ตามด้วย b บิตเพิ่มเติมแทน k

ดังนั้นตัวเลข p * (2 ^ b) + k สำหรับ 0 <= k <= n-1, เมื่อเขียนด้วยเลขฐานสองทั้งหมดเริ่มต้นด้วยการแทนเลขฐานสองของ p แต่นี่คือจำนวนที่ต่อเนื่องกัน 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∧

ลองออนไลน์!

มีมากกว่าหนึ่งวิธีในการเขียนสิ่งนี้ใน 14 ไบต์ใน Brachylog ดังนั้นฉันจึงไปเพื่อประสิทธิภาพสูงสุด เป็นเรื่องปกติสำหรับการส่ง Brachylog นี่คือการส่งฟังก์ชั่น อินพุตของมันคือ semiprime เอาต์พุตของมันคือตัวคูณ

คำอธิบาย

ḋḃᵐ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%$_)ส่งสิ่งเหล่านั้นลงในลูป|%{...}และconverts แต่ละรายการเป็น2สตริงไบนารี (ฐาน) $aร้านค้าเหล่านั้นสตริงไบนารีใน

จากนั้นเราเข้าสู่for(){...}วงวนไม่สิ้นสุด แต่ละซ้ำเราเพิ่ม++$mคูณว่าด้วย$nและที่เป็นสตริงไบนารีเก็บไว้ในconvert $bจากนั้นifสตริงที่เป็น regex -likeสตริงใด ๆ ในการ$aที่เราส่งออกและ$mexit

Perl 6 , 66 ไบต์

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

Regex ตาม

ช้าสุด ๆ เพราะมันดุร้ายกับปัจจัยของnอีกครั้งในทุกตำแหน่งการแข่งขันของ regex ทุกหมายเลขที่พยายาม

การคำนวณปัจจัยเพียงครั้งเดียวช่วยเพิ่มประสิทธิภาพ แต่ทำให้มีขนาด 72 ไบต์:

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