บางครั้งเมื่อเขียนโปรแกรมคุณต้องใช้จำนวนเฉพาะด้วยเหตุผลบางอย่างหรืออื่น ๆ (เช่นการเข้ารหัส) ฉันคิดว่าบางครั้งคุณต้องใช้หมายเลขคอมโพสิตด้วย บางครั้งอย่างน้อยที่นี่ใน PPCG โปรแกรมของคุณจะต้องสามารถจัดการกับการเปลี่ยนแปลงโดยพลการ และในสถานการณ์ที่วางแผนจะสร้างคำถาม PPCG ที่น่าสนใจอย่างสะดวกสบายบางทีแม้แต่ตัวเลขที่คุณใช้ก็ต้องทนต่อการทุจริต ...

คำนิยาม

จำนวนคอมโพสิตเป็นจำนวนเต็ม≥ 4 ที่ไม่ได้เป็นนายกคือมันเป็นผลิตภัณฑ์ของจำนวนเต็มสองจำนวนที่มีขนาดเล็กมากกว่า 1 ต่อ A bitflip ทนจำนวนคอมโพสิตถูกกำหนดให้เป็นดังนี้ก็เป็นจำนวนเต็มบวกคอมโพสิตซึ่งถ้าคุณเขียนมัน ในเลขฐานสองในจำนวนบิตที่น้อยที่สุดที่เป็นไปได้คุณสามารถเปลี่ยนหนึ่งหรือสองบิตจากจำนวนและจำนวนยังคงประกอบ

ตัวอย่าง

ตัวอย่างเช่นพิจารณาจำนวน 84 1010100ในไบนารีว่า นี่คือตัวเลขทั้งหมดที่ต่างกันไม่เกิน 2 บิตจาก:

0000100 4 2 × 2
0010000 16 4 × 4
0010100 20 4 × 5
0010101 21 3 × 7
0010110 22 2 × 11
0011100 28 4 × 7
0110100 52 4 × 13
1000000 64 8 × 8
1000100 68 4 × 17
1000101 69 3 × 23
1000110 70 7 × 10
1001100 76 4 × 19
1010000 80 8 × 10
1010001 81 9 × 9
1010010 82 2 × 41
1010100 84 7 × 12
1010101 85 5 × 17
1010110 86 2 × 43
1010111 87 3 × 29
1011000 88 8 × 11
1011100 92 4 × 23
1011101 93 3 × 31
1011110 94 2 × 47
1100100 100 10 × 10
1110000 112 8 × 14
1110100 116 4 × 29
1110101 117 9 × 13
1110110 118 2 × 59
1111100 124 4 × 31

คอลัมน์แรกคือตัวเลขในไบนารี คอลัมน์ที่สองคือตัวเลขเป็นทศนิยม ตามที่ระบุในคอลัมน์ที่สามตัวเลขทั้งหมดเหล่านี้ประกอบกัน ด้วยเหตุนี้ 84 จึงเป็นเลขคอมโพสิตที่ทนต่อการพลิกผัน

งาน

คุณต้องเขียนหนึ่งในสามโปรแกรมต่อไปนี้หรือฟังก์ชั่นใดก็ตามที่เหมาะสมกับภาษาของคุณมากที่สุด:

• โปรแกรมหรือฟังก์ชั่นที่ใช้เวลาติดลบnเป็น input และผลแรกnตัวเลขประกอบ bitflip ทน
• โปรแกรมหรือฟังก์ชั่นที่รับจำนวนเต็มn ที่ไม่ต้องการลบเป็นอินพุตและส่งออกหมายเลขคอมโพสิตที่ทนต่อการ Bitflip น้อยกว่าn (หรือหากคุณต้องการน้อยกว่าหรือเท่ากับnนั่นคือคุณสามารถเลือกได้ว่าจะรวมnในเอาต์พุตหรือไม่ ทน)
• โปรแกรมหรือฟังก์ชั่นที่ไม่มีอินพุตและเอาต์พุตหมายเลขคอมโพสิตที่ทนต่อการบิตไฟล์ทั้งหมด (สิ่งนี้จะต้องใช้กลไกเอาต์พุตที่สามารถสร้างเอาต์พุตในขณะที่โปรแกรมยังคงทำงานอยู่เช่นการพิมพ์ไปยัง stdout, รายการสันหลังยาวหรือเครื่องกำเนิดไฟฟ้าคุณไม่สามารถคำนวณรายการทั้งหมดแล้วพิมพ์ได้)

กรณีทดสอบ

นี่คือตัวเลขคอมโพสิตที่ทนต่อการบิตไฟล์แรก ๆ :

84, 184, 246, 252, 324, 342, 424, 468, 588, 636, 664, 670, 712, 730, 934, 958

ชี้แจง

• มันเป็นเพียงตัวเลขที่คุณสร้างขึ้นซึ่งจะต้องทนต่อ bitflips นี่ไม่ใช่งานเกี่ยวกับการทำให้โปรแกรมที่พวกเขาทนต่อ bitflips; ใช้ตัวเลขใด ๆ ในโปรแกรมที่คุณชอบ
• ตัวเลขที่คุณส่งออกไม่จำเป็นต้องทนต่อการเป็นบิตใน "เลขศูนย์นำหน้า" ลองนึกภาพว่าตัวเลขจะถูกเก็บไว้ในจำนวนบิตที่น้อยที่สุดเท่าที่จะเป็นไปได้และบิตเหล่านั้นเท่านั้นที่จะต้องมีภูมิคุ้มกันต่อการพลิก อย่างไรก็ตาม 1 บิตแรกเริ่มของตัวเลขที่คุณส่งออกจะต้องมีภูมิคุ้มกันต่อ bitflips
• ใช้อัลกอริทึมที่คุณชอบซึ่งให้ผลลัพธ์ที่ถูกต้อง คุณไม่ได้ทำเครื่องหมายประสิทธิภาพที่นี่
• หากคุณสามารถพิสูจน์ได้ว่ามีจำนวนคอมโพสิตที่ทนต่อ bitflip จำนวน จำกัด ดังนั้น a) ข้อ จำกัด ในรูปแบบเอาต์พุตถูกยกขึ้นและ b) การเข้ารหัส hardcoding รายการจะได้รับอนุญาต (แม้ว่าอาจจะ verbose มากกว่าการคำนวณ กฎนี้ส่วนใหญ่เป็นเพียงเพื่อความสมบูรณ์ ฉันไม่คาดหวังว่ามันจะเกี่ยวข้อง

เงื่อนไขชัยชนะ

นี่คือรหัสกอล์ฟดังนั้นตามปกติจะสั้นกว่าดีกว่า เช่นเคยความยาวของโปรแกรมจะถูกวัดเป็นไบต์

เยลลี่ 20 เม็ด 22 ไบต์

BµJŒċ;0Ṭ^µḄµÆPoỊṀ¬
⁴Ç#

ลองออนไลน์!

ส่งผลให้ตัวเลขแรกเช่นn

อาจจะ;0สามารถลบออกได้ (ถ้าไม่มีมันเราจะไม่ตรวจสอบว่าตัวเลขนั้นประกอบไปด้วยหรือไม่มีช่วงเวลาใดที่มีการรวมบิตแบบพลิกทั้งหมดหรือไม่)

โปรดทราบว่ามันไม่เพียงพอที่จะทำการทดสอบnot(any(is prime))กับชุดของตัวเลขบิตพลิก เราต้องทำการทดสอบที่0ไม่ได้อยู่ในชุดด้วย

นี่เป็นเพราะ0ไม่ใช่ตัวหลักและไม่ประกอบ ( 1เกินไป แต่ดูด้านล่าง)

ความต้องการตรวจสอบ0อาจดูได้จากตัวอย่างเคาน์เตอร์:

• 131136( 2 ¹⁷ +2 ⁶ ) มีชุด bit-flip ดังต่อไปนี้:

[0, 64, 65, 66, 68, 72, 80, 96, 192, 320, 576, 1088, 2112, 4160, 8256, 16448, 32832, 65600, 131072, 131073, 131074, 131076, 131080, 131088, 131104, 131136, 131137, 131138, 131139, 131140, 131141, 131142, 131144, 131145, 131146, 131148, 131152, 131153, 131154, 131156, 131160, 131168, 131169, 131170, 131172, 131176, 131184, 131200, 131264, 131265, 131266, 131268, 131272, 131280, 131296, 131328, 131392, 131393, 131394, 131396, 131400, 131408, 131424, 131520, 131584, 131648, 131649, 131650, 131652, 131656, 131664, 131680, 131776, 131904, 132096, 132160, 132161, 132162, 132164, 132168, 132176, 132192, 132288, 132416, 132672, 133120, 133184, 133185, 133186, 133188, 133192, 133200, 133216, 133312, 133440, 133696, 134208, 135168, 135232, 135233, 135234, 135236, 135240, 135248, 135264, 135360, 135488, 135744, 136256, 137280, 139264, 139328, 139329, 139330, 139332, 139336, 139344, 139360, 139456, 139584, 139840, 140352, 141376, 143424, 147456, 147520, 147521, 147522, 147524, 147528, 147536, 147552, 147648, 147776, 148032, 148544, 149568, 151616, 155712, 163840, 163904, 163905, 163906, 163908, 163912, 163920, 163936, 164032, 164160, 164416, 164928, 165952, 168000, 172096, 180288, 196608, 196672, 196673, 196674, 196676, 196680, 196688, 196704, 196800, 196928, 197184, 197696, 198720, 200768, 204864, 213056, 229440]

ซึ่งทั้งหมดยกเว้น0คอมโพสิต แต่0ก็ไม่ได้สำคัญ

1ยังเป็นแบบไม่เฉพาะและไม่ประกอบและอาจปรากฏในชุด อย่างไรก็ตามเราสามารถทำได้ถ้าเราต้องการให้มันเป็นคอมโพสิต:

• อินพุตทั้งหมดที่น้อยกว่าหรือเท่ากับ3(หากพิจารณาทั้งหมด) มีส่วนประกอบ0อยู่แล้ว (ในความเป็นจริงทั้งหมดน้อยกว่าที่7ทำ)

• ในการเข้าถึง1ในการพลิกหนึ่งบิตหมายเลขดั้งเดิมจะต้องอยู่ในรูปแบบ2 ^k +2 ⁰และถ้านี่มากกว่า3เช่นk> 1จากนั้นเราสามารถเข้าถึงได้3โดยพลิกk -bit และตั้งค่า1บิต ( 2 ¹ +2 ⁰ = 3 )

• ในการไปถึงการ1พลิกแบบสองบิตหมายเลขเดิมจะต้องอยู่ในรูปแบบ2 ^kและถ้านี่มากกว่าที่3เราจะไปถึงได้2ในการโยนแบบสองครั้งแทนและ2ถือว่ายอดเยี่ยม

ขณะที่มันยืนรหัสจะจัดการทั้ง0และ1ร่วมกันใช้ "นัยสำคัญ" Ịอะตอม

อย่างไร?

⁴Ç# - Main link: n
⁴   - 16
  # - count up from 16 finding the first n matches of
 Ç  -     last link (1) as a monad

BµJŒċ;0Ṭ^µḄµÆPoỊṀ¬ - Link 1, test a number: i
B                  - convert to a binary list
 µ                 - start a new monadic chain
  J                - range(length): [1,2,...,nBits]
   Œċ              - pairs with replacement: [[1,1],[1,2],...,[1,nBits],[2,2],[2,3],...,[2,nBits],...,[nBits-1,nBits]]
     ;0            - concatenate a zero
       Ṭ           - untruth (makes lists with ones at those indexes - the [1,1], [2,2], etc make the one-flips, the zero makes the no-flip, the rest make the two-flips)
        ^          - exclusive or with the binary list version of i (flip the bits)
         µ         - start a new monadic chain
          Ḅ        - un-binary (get the integer values of each of the flipped versions)
           µ       - start a new monadic chain
            ÆP     - is prime? (make a list of 1s for primes and 0 for non-primes)
               Ị   - is insignificant (abs(v)<=1)
              o    - logical or (now we have true for any primes, 0 or 1 - hence non-composites)
                Ṁ  - maximum (1 if any non-composite was found)
                 ¬ - not (1 if all were composite)

Brachylog , 32 38 ไบต์

2<≜.¬(ḃ↰₂↰₂~ḃ≜{ṗ|ℕ<2}∧)
k~k|tgT∧?k↰:Tc

ลองออนไลน์!

นี่คือฟังก์ชัน / เพรดิเคต↰₀ที่ส่งคืนตัวสร้างที่สร้างหมายเลขดังกล่าวทั้งหมด (ลิงก์ TIO พิมพ์เฉพาะหมายเลขแรกเท่านั้นเพื่อให้สิ่งที่สังเกตได้การเรียกใช้ในพื้นที่ผลิตได้มากกว่านั้น)

ตอนนี้อัปเดตเพื่อจัดการหมายเลขที่อยู่ภายในสองบิตเป็น 0 หรือ 1 (ซึ่งไม่ใช่แบบไพรม์หรือคอมโพสิต) อย่างถูกต้อง

คำอธิบาย

Helper predicate ↰₂ (คืนค่ารายการที่เท่ากับอินพุตยกเว้นบางทีองค์ประกอบเดียว)

k~k|tgT∧?k↰:Tc
   |            Either:
 ~k               the output is produced by appending an arbitrary element
k                 to the input minus its last element
                Or:
        ?k        take the input minus its last element,
          ↰       call this predicate recursively on that,
      T    :Tc    then append
     g            the singleton list consisting of
    t             the last element of the input

ฉันจะรักมันถ้ามีวิธีการทำซ้ำการทำแบบนี้ค่อนข้างง่าย แต่ฉันไม่แน่ใจว่ายังมี; มีคุณสมบัติที่ดูมีแนวโน้มในสเปค แต่มันถูกทำเครื่องหมายว่าไม่ได้ใช้งาน

โปรแกรมหลัก ↰₀

2<≜.¬(ḃ↰₂↰₂~ḃ≜{ṗ|ℕ<2}∧)
2<≜                      For each integer greater than 2
   .                     generate it if
    ¬(                )  it does not have the following property:
      ḃ                  converting it to binary,
       ↰₂↰₂              running the helper predicate twice,
           ~ḃ            and converting back to decimal
             ≜           does not allow us to find a specific value
              {     }    that is:
               ṗ           prime;
                |        or:
                 ℕ<2       nonnegative and less than 2
                     ∧   (disable an unwanted implicit constraint)

JavaScript (ES6), 96 ไบต์

alert()โปรแกรมเต็มรูปแบบที่แจ้งสำหรับจำนวนของการจับคู่จำนวนเต็มและแสดงให้พวกเขาหนึ่งโดยหนึ่งโดยใช้

for(i=prompt(n=2);i;n+=2)(g=b=>b>n?alert(n,i--):(C=(n,x=n)=>n%--x?C(n,x):x>1)(n^b|1)&&g(b*2))(1)

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

ด้านล่างเป็นรุ่นที่ไม่เกิดซ้ำ (102 ไบต์)

for(i=prompt(n=2);i;n+=2){for(c=b=1;b<n;b*=2,c&=C)for(C=k=2,x=n^b|1;k<x;k++)C|=!(x%k);c&&alert(n,i--)}

การสันนิษฐาน

อัลกอริทึมนี้ขึ้นอยู่กับสมมติฐานที่ว่าหมายเลขคอมโพสิตที่ทนต่อการพลิกผันทั้งหมดจะเท่ากัน สิ่งนี้นำไปสู่การทำให้เข้าใจง่ายขึ้นค่อนข้างสำคัญ: แทนที่จะพลิกบิตทุกคู่ที่เป็นไปได้เราพลิกบิต # 0 และอีกอันหนึ่ง (หรือไม่มีบิตอื่นเลย) และตรวจสอบว่าตัวเลขที่เกิดขึ้นทั้งหมดประกอบกัน

อย่างไรก็ตามฉันไม่สามารถหาข้อพิสูจน์ที่ชัดเจนได้ว่าไม่มีหมายเลขคอมโพสิตที่ทนต่อการพลิกด้วยบิต มันเกิดขึ้นไม่ได้กับกรณีของตัวเลขขนาดเล็ก (ฉันตรวจสอบได้มากถึง 1,000,000) และดูเหมือนว่าความน่าจะเป็นที่จะหาหนึ่งจะลดลงเนื่องจากจำนวนบิตเพิ่มขึ้น (แต่นี่เป็นเพียงสัญชาตญาณของฉัน)

เยลลี่ , 20 17 ไบต์

BJŒċṬUḄ^;⁸ÆḍṂỊµÐḟ

ลองออนไลน์!

มันทำงานอย่างไร

BJŒċṬUḄ^;⁸ÆḍṂỊµÐḟ  Main link. Argument: n

              µ    Combine all links to the left into a chain.
               Ðḟ  Filter-false; keep only integers k from [1, ..., n] for which
                   the chain returns 0.
B                    Convert k to binary.
 J                   Get the indices of all digits.
  Œċ                 Take all combination of two indices, with replacement.
    Ṭ                Untruth; map each index pair [i, j] to the Boolean array of
                     length j that has 1's at (and only at) indices i and j.
     U               Upend; reverse each Boolean array.
      Ḅ              Unbinary; convert each array from base 2 to integer.
       ^             XOR the resulting numbers with k.
        ;⁸           Append k to the resulting list.
          Æḍ         Count the number of proper divisors of each result.
            Ṃ        Take the minimum.
             Ị       Insignificant; test if the minimum is 0 or 1.

Python 2, 113 ไบต์

r=range
lambda N:[n for n in r(1,N)if 1-any((bin(k).count('1')<3)*all((n^k)%q for q in r(2,n^k))for k in r(n+1))]

(บรรทัดที่สองเป็นฟังก์ชั่นที่ไม่มีชื่อซึ่งจะส่งกลับรายการของหมายเลขคอมโพสิตที่ทนต่อการพลิกด้วยบิตซึ่งน้อยกว่าการป้อนข้อมูลเข้าสู่ฟังก์ชั่น)

ไวยากรณ์all(u%q for q in range(2,u))จะประเมินไปTrueเมื่อใดก็ตามที่uเป็นทั้งนายกหรือน้อยกว่าหรือเท่ากับ2และอื่น ๆ Falseจะมีการประเมินเพื่อ (มันจะว่างเปล่าTrueถ้าuน้อยกว่าหรือเท่ากับ2)

กล่าวอีกนัยหนึ่งall(u%q for q in range(2,u))ก็คือ0ถ้าเท่ากับและถ้าuเป็นคอมโพสิต

หากอินพุตของฟังก์ชันน้อยกว่า2ฟังก์ชันจะส่งคืนรายการว่าง (ตามต้องการ) ดังนั้นถือว่าการป้อนข้อมูลNเป็นอย่างน้อยและคิดว่า2 1 <= n < Nสำหรับแต่ละkจาก0ถึงn(รวม) รหัสจะตรวจสอบว่าnXOR kจะมีคอมโพสิตหรือไม่และยังตรวจสอบว่าkมีสองอย่างมากที่สุด1ในการเป็นตัวแทนไบนารี ถ้าn^kเป็นคอมโพสิตหรือถ้าkมีมากกว่าสอง1's kแล้วก็ย้ายไปค่าต่อไปของ หากได้รับค่าทั้งหมดkจากจาก0ด้วยnวิธีนี้ก็จะรวมnอยู่ในรายการ

ในทางกลับกันหากมีค่าkที่มากที่สุดสอง1อย่างที่n^kไม่ได้เป็นคอมโพสิตก็nจะไม่รวมอยู่ในรายการ

Perl 6 , 87 85 ไบต์

{grep {!grep {$_%all 2..^$_},($_ X+^grep {.base(2)~~m:g/1/ <3},^(2+<.log(2)))},2..$_}

ส่งคืนตัวเลขดังกล่าวทั้งหมดที่เล็กกว่าหรือเท่ากับจำนวนอินพุต

มันทำงานอย่างไร

สำหรับแต่ละหมายเลขnจาก 2 ถึงอินพุตมันทำดังต่อไปนี้:

1. ^ (2 + <.log (2))

   สร้างทั้งหมด integers เชิงลบที่มีความยาวบิตเดียวกันหรือสั้นกว่าn

2. grep {.base (2) ~~ m: g / 1 / <3},

   กรองตัวเลขจากรายการนี้ที่มีการตั้งค่าน้อยกว่าสามบิต (โดยใช้ regex)

3. $ _ X + ^

   แฮคเกอร์ของnกับแต่ละตัวเลขเหล่านั้นยอมที่ถูกต้องทั้งหมด "กลายพันธุ์" ของn

4. ! grep {$ _% ทั้งหมด 2 .. ^ $ _}

   อนุญาตให้nเป็นส่วนหนึ่งของรายการเอาต์พุตเท่านั้นหากไม่มีการกลายพันธุ์ใด ๆ ที่ไม่ใช่แบบประกอบ (ตรวจสอบโดยใช้การกลายพันธุ์แต่ละตัวx modulo เป็นทางแยกทั้งหมดของตัวเลขระหว่าง 2 ถึงx -1)

Mathematica, 115 ไบต์

1 4 ไบต์บันทึกขอบคุณ @MartinEnder

Cases[4~Range~#,x_/;And@@CompositeQ[Fold[#+##&]/@Select[{0,1}~Tuples~BitLength@x,Tr@Abs[#-x~IntegerDigits~2]<3&]]]&

(* or *)

(s=Select)[4~Range~#,xAnd@@CompositeQ[Fold[#+##&]/@s[{0,1}~Tuples~BitLength@x,Tr@Abs[#-x~IntegerDigits~2]<3&]]]&

ไม่มีประสิทธิภาพมากเพราะมันสร้างตัวเลขทั้งหมดได้ถึง 2 ^ ceil (lg (n))

โค้ดที่สองใช้ U + F4A1 ( Functionฟังก์ชั่น)

Floroid , 95 109 ไบต์

Bj:[n KnIw(j)Fp(Cao(hm("".y(k)))Mhm("".y(k))>1KkIcd("10"*Z(hi(n)),Z(hi(n)))FT(a!=b Ka,bIq(hi(n),"".y(k)))<3)]

ส่งคืนรายการตัวเลขที่ทนต่อการพลิกผันได้ถึง input - 1ทนขึ้นไป จัดการกับสถานการณ์หงุดหงิด (0 และ 1) เช่นกัน

Floroid เป็นภาษาเก่าแก่ของฉันที่ฉันได้ใช้เพียงไม่กี่ครั้ง ยังไม่ได้สัมผัสมันเป็นเวลานานมากขนาดของโปรแกรม

แปลเป็นรหัส Python ต่อไปนี้ซึ่งฉันคิดว่าสามารถลดลงได้ด้วยการเรียกซ้ำ

lambda j:[n for n in  range(j) if  all( not  functions.isPrime( functions.fromBinStr("".join(k))) and  functions.fromBinStr("".join(k))>1for k in  functions.combinations_with_replacement("10"*len( functions.pureBin(n)),len( functions.pureBin(n))) if sum (a!=b for a,b in  zip( functions.pureBin(n),"".join(k)))<3)]

แต่ละฟังก์ชั่นที่ใช้ที่นี่ถูกกำหนดไว้ล่วงหน้าใน Floroid หน้านี้มีฟังก์ชั่นและคำจำกัดความทั้งหมด

MATL , 30 28 27 26 ไบต์

:GBnW:qtB!s3<)!Z~tZpw~+a~f

ลองออนไลน์!

ส่งออกหมายเลขคอมโพสิตที่ทนต่อการบิตทั้งหมดจนถึง (และรวมถึง) n ใช้แนวคิดจากทั้งสองโซลูชั่นของเยลลี่ - พิจารณาว่า 0 เป็นเพียงปัญหาที่ไม่สำคัญเท่านั้น และสร้างรายการของตัวเลขภายในระยะทาง 2 ก่อนจากนั้นจึงใช้ xor

โซลูชันสำรองโดยการวนลูป (30 ไบต์):

:"@BnW:qt@Z~B!s3<)Zp1M~ha~?@D]

ส่งออกตัวเลขคอมโพสิตที่ทนต่อการพลิกผันได้ถึง

CJam , 34 33 ไบต์

ri{_2b,,2\f#_m*::|0+f^:mp:+!},2>p

คำนวณทุกคอมโพสิต bitflip ทนอย่างเคร่งครัดน้อยกว่าn

เช่นเดียวกับ Jonathan Allan ฉันไม่แน่ใจว่าจำเป็นหรือไม่ที่จะต้องตรวจสอบ 0 bitflips หากปรากฎว่าไม่มีหมายเลขสำคัญใด ๆ ที่มีผลลัพท์ของบิตแฟล็กทั้งหมดในจำนวนคอมโพสิต0+สามารถลบออกได้

ลองออนไลน์!

คำอธิบาย

ri                                 Take an integer from input (n)
  {                                Filter out all numbers in the range 0...n-1 for which
                                    the following block is false
   _                                 Duplicate the number
    2b,                              Convert to binary, get the length
       ,                             Range from 0 to length-1
        2\f#                         Map each number in that range as a power of 2
                                      results in all powers of 2 less than or equal to n
            _m*                      Cartesian product with itself
               ::|                   Reduce each Cartesian pair with btiwse OR
                                      results in all numbers that have 1-2 1 bits in binary
                  0+                 Add 0 to that list
                    f^               Bitwise XOR the number we're checking with each of these
                                      This computes all the bitflips
                      :mp            Map each result to 0 if it's prime, 1 if it's composite
                         :+!         Take the sum of the list, check if it's 0
                                      If it is, then none of the results were prime
                            },     (end of filter block)
                              2>   Discard the first 2 numbers, since 0 and 1 always pass
                                p  Print the list nicely

MATL , 29 ไบต์

ขอบคุณ Jonathan Allan สำหรับการแก้ไข

q:Q"@BtnFTZ^=~!s3<fqt2>)Zp~?@

นี้จะใช้เวลาเป็นจำนวนnและผลตัวเลขประกอบทั้งหมด bitflip ทนได้ถึงn

มันทำงานอย่างไร

ลองที่ MATL Online!

q:Q       % Input n implicitly. Push range [2 3 ... n]
"         % For each k in [2 3 ... n]
  @       %   Push k
  B       %   Convert to binary. Gives a row vector of zeros and ones, say v
  tn      %   Duplicate. Number of elements, say m
  FT      %   Push [0 1]
  Z^      %   Cartesian power of [0 1] raised to m. This gives a matrix,
          %   where each row is a binary number of length m
  =~      %   Compare with v, with broadcast
  !s      %   Sum of each row. Gives a row vector. This is the number of
          %   bit flips
  3<      %   True for numbers that are less than 3 bit flips away from k
  fq      %   Find their indices and subtract 1 to convert to decimal form.
          %   This gives a vector of numbers that are less than 3 bit flips
          %   away from k
  t2>)    %   Remove 0 or 1
  Zp~     %   Test each entry for non-primeness
?         % If all entries are true
  @       %   Push k
          % End (implicit)
          % Display stack (implicit)