Bazen, bir programı yazarken, bir neden veya başka bir sebep için bir asal sayı kullanmanız gerekir (örneğin kriptografi). Bazen bir kompozit sayı kullanmanız gerektiğini düşünüyorum. Bazen, en azından burada PPCG'de programınız isteğe bağlı değişikliklerle başa çıkabilmelidir. Ve ilginç bir PPCG sorusu yapmaya elverişli durumlarda, belki de kullandığınız sayıların bile yolsuzluğa karşı dayanıklı olması gerekir…

Tanımlar

Bir bileşik sayı o 1. A 'den büyük iki küçük tamsayılar ürünüdür, yani asal olmayan bir tamsayı ≥ 4 olan bitflip dayanıklı kompozit sayı şu şekilde tanımlanır: Eğer yazarsanız, bir kompozit pozitif tamsayı var Mümkün olan en az bit sayısında ikili olarak, herhangi bir veya iki biti, sayıdan değiştirebilirsiniz ve sayı hala birleşiktir.

Örnek

Örneğin, 84 sayısını düşünün. İkili olarak, bu 1010100. Ondan en fazla 2 bit farklılık göstermeyen tüm sayılar:

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

İlk sütun, ikilideki sayıdır; ikinci sütun ondalık sayıdır. Üçüncü sütunun işaret ettiği gibi, bu sayıların tümü birleşiktir. Bu nedenle, 84 bit kaymasına dirençli bir kompozit sayıdır.

Görev

Aşağıdaki üç program veya fonksiyondan birini yazmalısınız, hangisi diliniz için en anlamlı olanıdır:

• Negatif olmayan bir tamsayı alan bir program veya fonksiyon n girdi olarak ve ilk çıkış olarak N bitflip dirençli bileşik numaraları.
• Negatif olmayan bir tamsayıyı alan bir program veya fonksiyon , n girdi olarak ve daha az tüm bitflip dirençli bileşik numaraları verir n (veya daha az, tercih ya da eşit olması halinde n , yani seçebilir n bitflip ise çıkış dahildir dayanıklı).
• Giriş almayan ve tüm bit-fllip dirençli kompozit sayıları çıkartan bir program veya işlev. (Bu, program çalışırken stdout, tembel bir liste veya bir jeneratör gibi, hala çalışıyorken çıktı üretebilecek bir çıktı mekanizması kullanmalıdır; tüm listeyi hesaplayamaz ve sonra yazdıramazsınız.)

Test durumları

İşte ilk bit bitip dirençli kompozit sayılar:

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

Açıklamalar

• Sadece ürettiğiniz rakamlara, bit kliplerine karşı dayanıklı olması gerekir. Bu, bit bitlerine karşı onları bulan programı bulmaya yönelik bir görev değil; Programın kendisinde dilediğiniz sayıları kullanın.
• Çıktı aldığınız sayılar "baştaki sıfırlar" içindeki bir bit kaymasına karşı dayanıklı olmak zorunda değildir; sayıların mümkün olan en az sayıda bitte saklanacağını ve sadece bu bitlerin çevrilmeye karşı bağışık olması gerektiğini hayal edin. Ancak, çıktı aldığınız sayılardaki ilk 1 bit, bit kliplere karşı bağışık olmak zorundadır.
• Doğru sonucu üreten herhangi bir algoritmayı kullanın; Burada verimlilik konusunda işaretli değilsin.
• Sonunda bit bitmeye karşı dirençli birçok kompozit sayı olduğunu ispat ederseniz, a) çıktı formatındaki kısıtlamalar kaldırılır ve b) listeye kodlamaya izin verilir (muhtemelen sadece hesaplamaktan daha ayrıntılı olsa da). Bu kural çoğunlukla sadece bütünlük içindir; İlgili olmasını beklemiyorum.

Zafer durumu

Bu kod golf , normalde olduğu gibi, daha kısa. Her zamanki gibi, programın uzunluğu bayt olarak ölçülecektir.

Jelly , 20 mi? 22 bayt

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

Çevrimiçi deneyin!

İlk verir n böyle numaralar.

Belki ;0de kaldırılabilir (onsuz kendisinin sayının kompozit olup olmadığını kontrol etmeyiz - tüm bit-flips kompozitlerinde herhangi bir prim var mı?)

Testi bit saygısız sayılar kümesine gerçekleştirmenin yeterli olmadığını unutmayın not(any(is prime)). Ayrıca 0sette olmadığını test etmeliyiz .

Bunun nedeni 0asal değil ve kompozit olmamasıdır ( 1çok ama aşağıya bakınız).

Kontrol etme ihtiyacı 0bir karşı örnek tarafından görülebilir:

• 131136( 2 ¹⁷ +2 ⁶ ) aşağıdaki bit kapak kümesine sahiptir:

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

Bunların tümü, 0kompozit olanlar hariç , henüz 0asal değildir.

1aynı zamanda asal ve kompozit değildir ve sette görünebilir. Ancak, istersek bunu bir bileşikmiş gibi bırakabiliriz:

• Tüm girdiler 3(eğer kabul edilirse) eşit veya daha küçük ise 0yine de (aslında hepsinden daha az 7) içerir.

• erişebileceğimiz 1bir bit flip orijinal sayı biçiminde olmalıdır 2 ^k 2 ⁰ ve bu büyükse 3, yani k> 1 , o zaman ulaşabilir 3hareket çekiyor tarafından k bitlik ve ayar 1 -bit ( 2 ¹ + 2 ⁰ = 3 ).

• 1iki bitlik çevirilerde ulaşmak için orijinal sayı 2 ^k biçiminde olmalıdır ve eğer bu iki çevirme ile 3ulaşabileceğimizden büyükse , asaldır.22

Haliyle kodu iki işleyen 0ve 1, "küçük" atomu ile birlikte Ị.

Nasıl?

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

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

Çevrimiçi deneyin!

Bu, ↰₀tüm bu sayıları üreten bir jeneratör döndüren bir işlev / yordamdır . (TIO bağlantısı yalnızca ilk sayıyı yazdırır, bu nedenle bir şey gözlemlenebilir. Yerel olarak çalıştırmak, yine de daha fazlasını üretti.)

Artık 0 veya 1 olan iki bitlik klipteki (asal veya bileşik olmayan) sayıları doğru şekilde işlemek için güncellendi.

açıklama

Yardımcı yüklem ↰₂ (belki bir öğe hariç, girişe eşit bir liste döndürür)

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

Bu nispeten basit özyinelemeyi yapmanın ters bir yolu olsaydı çok isterdim, ama henüz olduğundan emin değilim; şartnamede ümit verici görünen bazı özellikler var, ancak bunlar uygulanmamış olarak işaretlendi.

Ana program ↰₀

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 bayt

Eşleşen tam sayıların sayısını isteyen ve bunları kullanarak tek tek görüntüleyen tam bir program 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)

Tarayıcınız Tail Call Optimization kullanacak şekilde ayarlanmadıkça, bu bir özyineleme taşması nedeniyle bozulacaktır.

Aşağıda yinelemeli olmayan bir sürüm (102 bayt).

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

Hazreti Meryem'in göğe kabulü

Bu algoritma, tüm bit-fllip-dirençli kompozit sayıların eşit olduğu varsayımına dayanır. Bu, oldukça önemli bir basitleştirmeye yol açar: olası her bit çiftini çevirmek yerine, sadece 0 # bitini ve bir diğerini çeviririz (ya da başka hiçbir bit değil) ve sonuçta elde edilen tüm sayıların kompozit olduğunu kontrol ederiz.

Ancak, tuhaf bir bit-fllip-dirençli kompozit sayının gerçekte var olmadığına dair kesin bir kanıt bulamıyorum. Bu sadece küçük sayılar için asla geçerli olmayacak (1.000.000'a kadar kontrol ettim) ve bit sayısı arttıkça birini bulma olasılığı düşüyor gibi gözüküyor (ama bu benim temelde benim düşüncem).

Jöle , 20 17 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

(İkinci satır, işleve girişten az olan tüm bit kayma dirençli bileşik sayıların bir listesini döndüren adlandırılmamış bir işlevdir.)

Sözdizimi all(u%q for q in range(2,u)), Truene zaman uasal ya da daha az ya da ona eşit olduğunda 2değerlendirir ve aksi takdirde değerlendirir False. (Daha küçük veya eşit Trueise , boş bir uşekilde uygulanır 2.)

Başka bir deyişle, eğer ve eğer kompozit ise all(u%q for q in range(2,u)), eşittir .0u

Eğer fonksiyonun girişi daha küçükse 2, fonksiyon boş bir liste (istenildiği gibi) döndürür. Yani girişin Nen azından 2olduğunu varsayalım ve varsayalım 1 <= n < N. Her biri için kgelen 0yoluyla n(dahili), kod olmadığını kontrol edecek nXOR ile kbileşik ve bunun olmadığını da kontrol eder ken az iki sahip 1'olan ikili gösteriminde s. Eğer n^kkompozit ise veya kikiden fazla 1ise, bir sonraki değerine geçer k. O bütün değerlerini yoluyla alırsa kgelen 0aracılığıyla nbu şekilde, o zaman kapsamaktadır nlistede.

Değeri varsa Öte yandan, ken fazla iki tane 1böyle s' n^kkompozit değildir, o zaman nlisteye dahil edilmez.

Perl 6 , 87 85 bayt

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

Giriş numarasına eşit veya daha küçük olan tüm bu sayıları döndürür.

Nasıl çalışır

2'den girişe her n sayısı için, aşağıdakileri yapar:

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

   N ile aynı veya daha kısa bit uzunluğuna sahip tüm negatif olmayan tam sayıları oluşturur .

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

   Üç listeden daha az ayarlanmış (bir regex kullanarak) bu listedeki sayıları filtreler.

3. $ _ X + ^

   XOR, n sayısının tüm geçerli "mutasyonlarını" veren, bu sayıların her birinde n'dir .

4. ! grep {$ _% tümü 2 .. ^ $ _}

   Sadece sağlayan n mutasyonların hiçbiri (her mutasyon alarak kontrol dışı kompozit ise çıkış listesinin parçası olmak x 2 ve aralarında sayıların bir all-Kavşağı modulo x -1).

Mathematica, 115 bayt

@MartinEnder sayesinde 1 4 bayt kurtarıldı

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

Çok verimsiz çünkü 2 ^ ce (lg (n)) değerine kadar olan tüm sayıları üretir.

İkinci kod U + F4A1 ( Functionişlev) kullanır

Floroid , 95 109 bayt

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

Kadar bit bit kaymaz sayıların listesini döndürür input - 1. Sinirli durumları (0 ve 1) da ele alır.

Floroid, benim sadece birkaç kez kullandığım eski bir dil. Programın boyutu, bu yüzden uzun süredir dokunmadım.

Özyineleme ile azaltılacağını düşündüğüm Python kodunu çevirir.

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

Burada kullanılan her fonksiyon Floroid'de önceden tanımlanmıştır. Bu sayfa tüm fonksiyonları ve tanımlarını içerir.

MATL , 30 28 27 26 bayt

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

Çevrimiçi deneyin!

N'ye (ve dahil) kadar tüm bit-bit dirençli kompozit sayıları çıkarır. Her iki Jelly çözümündeki fikirleri kullanır - yalnızca 0'ı sorunlu olmayan bir öncelikli olarak görür; ve önce 2 mesafesindeki bir sayılar listesini oluşturur, sonra xor alır.

Döngü yaparak alternatif çözüm (30 bayt):

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

N'ye (ve dahil) kadar tüm bit-bit dirençli kompozit sayıları çıkarır.

CJam , 34 33 bayt

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

Az kesinlikle her bitflip dirençli kompozit hesaplar n .

Jonathan Allan gibi, aslında 0 bitlik kartı kontrol etmenin gerekip gerekmediğinden emin değilim. Hiçbir asal sayının tüm bit kliplerinin bileşik sayılarla sonuçlanmadığı ortaya çıkarsa, 0+çıkartılabilir.

Çevrimiçi deneyin!

açıklama

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 bayt

Düzeltme için Jonathan Allan'a teşekkürler.

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

Bu sayı alır , n kadar ve tüm bitflip dirençli bileşik numaraları verir , n .

Nasıl çalışır

MATL Online'da deneyin!

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)