Đôi khi, khi viết chương trình, bạn cần sử dụng số nguyên tố vì lý do này hay lý do khác (ví dụ như mật mã). Tôi cho rằng đôi khi, bạn cũng cần sử dụng một số tổng hợp. Đôi khi, ít nhất là ở đây trên PPCG, chương trình của bạn phải có khả năng xử lý các thay đổi tùy ý. Và trong hoàn cảnh thuận tiện đặt ra một câu hỏi PPCG thú vị, có lẽ ngay cả những con số bạn đang sử dụng cũng phải chống lại tham nhũng.

Định nghĩa

Một số tổng hợp là một số nguyên ≥ 4 mà không phải là số nguyên tố, tức là nó là sản phẩm của hai số nguyên nhỏ hơn lớn hơn 1. Một số hợp bitflip chống được định nghĩa như sau: đó là một số nguyên dương composit mà, nếu bạn viết nó trong hệ nhị phân với số bit tối thiểu có thể, bạn có thể thay đổi bất kỳ một hoặc hai bit nào từ số đó và số vẫn là tổng hợp.

Thí dụ

Ví dụ, hãy xem xét số 84. Trong nhị phân, đó là 1010100. Dưới đây là tất cả các số khác nhau không quá 2 bit từ đó:

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

Cột đầu tiên là số ở dạng nhị phân; cột thứ hai là số thập phân. Như cột thứ ba chỉ ra, tất cả các số này là tổng hợp. Như vậy, 84 là một số tổng hợp kháng bitflip.

Nhiệm vụ

Bạn phải viết một trong ba chương trình hoặc chức năng sau đây, tùy theo ý nghĩa nhất đối với ngôn ngữ của bạn:

• Một chương trình hoặc hàm lấy số nguyên n không âm làm đầu vào và xuất ra các số tổng hợp kháng n bitflip đầu tiên .
• Một chương trình hoặc hàm lấy số nguyên n không âm làm đầu vào và xuất ra tất cả các số tổng hợp kháng bitflip nhỏ hơn n (hoặc nếu bạn thích, nhỏ hơn hoặc bằng n , tức là bạn có thể chọn n có được đưa vào đầu ra hay không nếu bitflip -tăng cường).
• Một chương trình hoặc hàm không có đầu vào và xuất ra tất cả các số tổng hợp kháng bitflip. (Điều này phải sử dụng cơ chế đầu ra có khả năng tạo đầu ra trong khi chương trình vẫn đang chạy, chẳng hạn như in ra thiết bị xuất chuẩn, danh sách lười biếng hoặc trình tạo; bạn không thể chỉ tính toàn bộ danh sách và sau đó in.)

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

Dưới đây là một số số tổng hợp kháng bitflip đầu tiên:

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

Làm rõ

• Đây chỉ là những con số bạn sản xuất phải có khả năng chống lại bitflips. Đây không phải là một nhiệm vụ về việc làm cho chương trình tìm thấy chúng kháng bitflips; sử dụng bất cứ số nào trong chính chương trình mà bạn thích.
• Các số bạn xuất ra không phải kháng bitflip trong "số 0 đứng đầu"; hãy tưởng tượng rằng các số đó sẽ được lưu trữ trong số bit tối thiểu có thể và chỉ những bit đó phải miễn nhiễm với việc lật. Tuy nhiên, 1 bit ban đầu trên các số bạn xuất ra phải miễn dịch với bitflips.
• Sử dụng bất kỳ thuật toán nào bạn thích mà tạo ra kết quả đúng; bạn không được đánh dấu về hiệu quả ở đây.
• Nếu bạn có thể chứng minh rằng có rất nhiều số tổng hợp kháng bitflip, thì a) các hạn chế về định dạng đầu ra được gỡ bỏ và b) mã hóa danh sách sẽ được cho phép (mặc dù có lẽ dài dòng hơn là chỉ tính toán). Quy tắc này chủ yếu chỉ để hoàn thiện; Tôi không mong đợi nó có liên quan.

Điều kiện chiến thắng

Đây là môn đánh gôn , vì vậy, như thường lệ, ngắn hơn là tốt hơn. Cũng như thường lệ, độ dài của chương trình sẽ được đo bằng byte.

Thạch , 20? 22 byte

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

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

Mang lại n số đầu tiên như vậy.

Có lẽ ;0có thể xóa (không có nó, chúng tôi không kiểm tra xem chính số đó có phải là số tổng hợp không - có bất kỳ số nguyên tố nào với tất cả các bit tổng hợp không?)

Lưu ý rằng việc thực hiện kiểm tra đối với tập hợp các số lật bit là không đủ not(any(is prime)). Chúng tôi cũng phải kiểm tra mà 0không có trong bộ.

Điều này là do 0không phải là số nguyên tố và không phải là tổng hợp ( 1quá, nhưng xem bên dưới).

Sự cần thiết phải kiểm tra 0có thể được nhìn thấy bằng một ví dụ ngược lại:

• 131136( 2 ¹⁷ +2 ⁶ ) có bộ bit-flip sau:

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

Tất cả trong số đó, ngoại trừ 0là tổng hợp, nhưng 0không phải là số nguyên tố.

1cũng không phải là số nguyên tố và không tổng hợp và có thể xuất hiện trong tập hợp. Tuy nhiên, chúng ta có thể, nếu chúng ta muốn, hãy để nó như thể nó là một hỗn hợp:

• tất cả các đầu vào nhỏ hơn hoặc bằng 3(nếu được xem xét ở tất cả) đều chứa một 0dù sao (thực tế tất cả đều ít hơn 7làm).

• để tầm 1trong một chút lật số lượng ban đầu phải có dạng 2 ^k 2 ⁰ , và nếu điều này là lớn hơn 3, tức là k> 1 , sau đó chúng ta có thể đạt được 3bằng cách lật ngoài khơi k bit và thiết lập 1 bit ( 2 ¹ +2 ⁰ = 3 ).

• để đạt được 1trong hai lần lật, số ban đầu phải có dạng 2 ^k và nếu số này lớn hơn 3chúng ta có thể đạt được 2trong hai lần lật, và 2là số nguyên tố.

Vì nó đứng mã đang xử lý cả hai 0và 1cùng nhau bằng cách sử dụng nguyên tử "không đáng kể" , Ị.

Làm sao?

⁴Ç# - 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 byte

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

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

Đây là một hàm / vị ngữ ↰₀trả về một trình tạo tạo ra tất cả các số đó. (Liên kết TIO chỉ in số đầu tiên, sao cho có thể quan sát được. Tuy nhiên, việc chạy nó cục bộ đã tạo ra nhiều hơn nữa.)

Bây giờ được cập nhật để xử lý các số nằm trong hai bitflips 0 hoặc 1 (không phải là số nguyên tố hay tổng hợp) một cách chính xác.

Giải trình

Vị ngữ trợ giúp ↰₂ (trả về một danh sách bằng với đầu vào, ngoại trừ có thể là một phần tử)

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

Tôi thích nó nếu có một cách khó khăn hơn để thực hiện đệ quy tương đối đơn giản này, nhưng tôi không chắc là có; có một số tính năng trông đầy hứa hẹn trong đặc tả, nhưng chúng được đánh dấu là chưa được thực hiện.

Chương trình chính ↰₀

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 byte

Một chương trình đầy đủ nhắc số lượng số nguyên phù hợp và hiển thị từng số một, sử dụng 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)

Trừ khi trình duyệt của bạn được thiết lập để sử dụng Tối ưu hóa cuộc gọi Tail, điều này cuối cùng sẽ bị hỏng do tràn đệ quy.

Dưới đây là phiên bản không đệ quy (102 byte).

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--)}

Giả định

Thuật toán này dựa trên giả định rằng tất cả các số tổng hợp kháng bitflip là chẵn. Điều này dẫn đến một sự đơn giản hóa khá quan trọng: thay vì lật mọi cặp bit có thể, chúng ta chỉ lật bit # 0 và một bit khác (hoặc không có bit nào khác) và kiểm tra xem tất cả các số kết quả có phải là tổng hợp không.

Tuy nhiên, tôi không thể tìm ra bất kỳ bằng chứng rõ ràng nào cho thấy số hỗn hợp kháng bitflip kỳ lạ không thực sự tồn tại. Nó chỉ xảy ra với số lượng nhỏ (tôi đã kiểm tra tới 1.000.000) và có vẻ như xác suất tìm thấy nó đang giảm khi số bit đang tăng (nhưng về cơ bản đây chỉ là trực giác của tôi về nó).

Thạch , 20 17 byte

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

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

Làm thế nào nó hoạt động

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 byte

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))]

(Dòng thứ hai là một hàm không tên, trả về một danh sách tất cả các số tổng hợp kháng bitflip nhỏ hơn đầu vào của hàm.)

Cú pháp all(u%q for q in range(2,u))sẽ đánh giá Truebất cứ khi nào ulà số nguyên tố hoặc nhỏ hơn hoặc bằng 2và nếu không sẽ đánh giá False. (Nó bị bỏ trống Truenếu unhỏ hơn hoặc bằng 2.)

Nói cách khác, all(u%q for q in range(2,u))bằng với 0khi và chỉ khi ulà tổng hợp.

Nếu đầu vào của hàm nhỏ hơn 2, thì hàm sẽ trả về một danh sách trống (như mong muốn). Vì vậy, giả sử đầu vào Nlà ít nhất 2, và giả sử 1 <= n < N. Đối với mỗi ktừ 0thông qua n(bao gồm), mã sẽ kiểm tra xem nXOR với bản klà composite, và nó cũng kiểm tra xem kcó ít nhất hai 1là trong biểu diễn nhị phân của nó. Nếu n^klà hợp số hoặc nếu kcó nhiều hơn hai 1, thì nó sẽ chuyển sang giá trị tiếp theo của k. Nếu nó thông qua tất cả các giá trị ktừ 0thông qua ncách này, thì nó bao gồm ntrong danh sách.

Mặt khác, nếu có một giá trị kvới ít nhất hai 1là như vậy mà n^kkhông phải là composite, sau đó nkhông được bao gồm trong danh sách.

Perl 6 , 87 85 byte

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

Trả về tất cả các số như vậy nhỏ hơn hoặc bằng số đầu vào.

Làm thế nào nó hoạt động

Đối với mỗi số n từ 2 đến đầu vào, nó thực hiện như sau:

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

   Tạo tất cả các số nguyên không âm có cùng độ dài bit ngắn hơn n .

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

   Lọc các số từ danh sách này có ít hơn ba bit được đặt (sử dụng biểu thức chính quy).

3. $ _ X + ^

   XOR n với mỗi số đó, thu được tất cả các "đột biến" hợp lệ của n .

4. ! grep {$ _% tất cả 2 .. ^ $ _}

   Chỉ cho phép n là một phần của danh sách đầu ra nếu không có đột biến nào là không tổng hợp (được kiểm tra bằng cách lấy mỗi đột biến x modulo một liên kết số giữa 2 và x -1).

Toán học, 115 byte

1 4 byte được lưu nhờ @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&]]]&

Rất không hiệu quả vì nó tạo ra tất cả các số lên tới 2 ^ ceil (lg (n)).

Mã thứ hai sử dụng U + F4A1 ( Functionchức năng)

Floroid , 95 109 byte

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)]

Trả về danh sách các số kháng bitflip lên đến input - 1 . Xử lý các tình huống khó chịu (0 và 1) là tốt.

Floroid là một ngôn ngữ cũ của tôi, mà tôi chỉ sử dụng một vài lần. Không được chạm vào nó trong một thời gian, do đó kích thước của chương trình.

Dịch sang mã Python sau, mà tôi nghĩ có thể được giảm với đệ quy.

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)]

Mỗi chức năng được sử dụng ở đây được xác định trước trong Floroid. Trang này chứa tất cả các chức năng và định nghĩa của chúng.

MATL , 30 28 27 26 byte

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

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

Xuất ra tất cả các số tổng hợp kháng bitflip lên đến (và bao gồm) n. Sử dụng ý tưởng từ cả hai giải pháp Jelly - chỉ coi 0 là một vấn đề không chính; và tạo một danh sách các số trong khoảng cách 2 trước, sau đó lấy xor.

Giải pháp thay thế, bằng cách lặp (30 byte):

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

Xuất ra tất cả các số tổng hợp kháng bitflip lên đến (và bao gồm) n.

CJam , 34 33 byte

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

Tính toán tất cả các vật liệu tổng hợp kháng bitflip nhỏ hơn n .

Giống như Jonathan Allan, tôi không chắc có thực sự cần thiết để kiểm tra 0 bitflips không. Nếu nó chỉ ra rằng không có số nguyên tố nào có tất cả các bitflips của nó dẫn đến số tổng hợp, thì 0+có thể loại bỏ.

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

Giải trình

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 byte

Cảm ơn Jonathan Allan cho một sự điều chỉnh.

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

Điều này nhận một số n và xuất ra tất cả các số tổng hợp kháng bitflip lên đến n .

Làm thế nào nó hoạt động

Hãy thử nó tại 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)