Bu meydan okumayı yaptığım bütün yıllar boyunca, 2017 birinci sınıf olan ilk yıl. Bu yüzden soru asal sayılar ve özellikleriyle ilgili olacaktır.

Göreviniz, girişte keyfi olarak büyük pozitif bir tamsayı alacak bir program veya işlev üretmek ve sayının 2,017 gevrek olup olmadığının çıktısını alması veya döndürmesidir - yani, bu sayıdaki en büyük ana faktör 2,017 veya daha az olup olmadığı.

Bazı örnek girdiler ve çıktıları:

1 (has no prime factors)
true

2 (= 2)
true

80 (= 2 x 2 x 2 x 2 x 5)
true

2017 (= 2017)
true

2019 (= 3 x 673)
true

2027 (= 2027)
false

11111 (= 41 x 271)
true

45183 (= 3 x 15061)
false

102349 (= 13 x 7873)
false

999999 (= 3 x 3 x 3 x 7 x 11 x 13 x 37)
true

1234567 (= 127 x 9721)
false

4068289 (= 2017 x 2017)
true

Programınızın kelimenin tam anlamıyla çıktısı olması trueve false- herhangi bir hakikat ya da sahte değer olması gerekmez ve gerçekte, doğru ve yanlış durumlarda tutarlı olan iki farklı çıktı iyidir.

Ancak, kaynak kodunuzda hiçbir prim kullanamazsınız . Asal iki tür gelir:

• Asal sayı değişmezlerini temsil eden karakterler veya karakter dizileri.

  • Karakterleri 2, 3, 5ve 7sayılar geçerli belirteçleri olan dilde yasadışı.

  • Numara 141o içerdiğinden yasadışı 41olsa da 1ve 4aksi geçerlidir.

  • Karakterler Bve D(veya bve d), genellikle CJam veya Befunge gibi 11 ve 13 olarak kullanıldığı dillerde yasa dışıdır.

• Asal değerli Unicode değerlerine sahip veya kodlarında asal değerli bayt içeren karakterler.

  • Karakterler %)+/5;=CGIOSYaegkmqASCII’de ve satır başı karakterlerinde geçersizdir.

  • Karakter ókodlaması 0xb3içinde olduğundan UTF-8'de geçersizdir . Bununla birlikte, ISO-8859-1'de kodlaması basit 0xf3, ki bu bileşik ve dolayısıyla tamam.

Herhangi bir dilde yukarıdakileri yapmak için en kısa kod kazanır.

Jöle , 8 bayt

44‘²!*ḍ@

Çevrimiçi deneyin! 11111 ve üzeri test durumlarının TIO için biraz fazla olduğuna dikkat edin.

Doğrulama

$ source="34,34,fc,82,21,2a,d5,40"
$ xxd -ps -r > 2017.jelly <<< $source
$ xxd -g 1 2017.jelly
0000000: 34 34 fc 82 21 2a d5 40                          44..!*.@
$ eval printf '"%d "' 0x{$source}; echo # Code points in decimal
52 52 252 130 33 42 213 64
$ test_cases="1 2 80 2017 2019 2027 11111 45183 102349 999999 1234567 4068289"
$ for n in $test_cases; do printf "%11d: %d\n" $n $(jelly f 2017.jelly $n); done
      1: 1
      2: 1
     80: 1
   2017: 1
   2019: 1
   2027: 0
  11111: 1
  45183: 0
 102349: 0

Test 999999 , 13 saattir çalışıyor. 2025’in hesaplanmasında kötümserim ! ^4068289 ...

Nasıl çalışır

44‘²!*ḍ@  Main link. Argument: n

44        Yield 44.
  ‘       Increment to yield 45.
   ²      Square to yield 2025.
          Note that no integers in [2018, ..., 2025] are prime numbers.
    !     Take the factorial of 2025.
     *    Raise it to the n-th power.
          This repeats all prime factors in 2025! at least n times, so the result
          will be divisible by n if (and only if) all of its prime factors fall
          in the range [1, ..., 2025].
      ḍ@  Test the result for divisibility by n.

Jöle , 8 karakter, UTF-8'in 14 baytı

Æf½ṀḤ<90

Çevrimiçi deneyin!

Jelly normalde programlar için kendi kod sayfasını kullanır. Bununla birlikte, birincil ile ilişkili yapıların çoğu, Æ13 kod noktası olan ile başlar ; çok yardımcı değil. Neyse ki, tercüman ayrıca bir dostça kodlamaya sahip olan UTF-8'i de destekliyor.

Doğrulama

Bu program, UTF-8'de hexdumps şöyle:

00000000: c386 66c2 bde1 b980 e1b8 a43c 3930  ..f........<90

Tüm baytların kompozit olduğunu doğrulama:

$ for x in c3 86 66 c2 bd e1 b9 80 e1 b8 a4 3c 39 30; do factor $((0x$x)); done
195: 3 5 13
134: 2 67
102: 2 3 17
194: 2 97
189: 3 3 3 7
225: 3 3 5 5
185: 5 37
128: 2 2 2 2 2 2 2
225: 3 3 5 5
184: 2 2 2 23
164: 2 2 41
60: 2 2 3 5
57: 3 19
48: 2 2 2 2 3

Tüm Unicode kod noktalarının kompozit olduğunu doğrulama:

$ perl -Mutf8 -E '$a = ord, print `factor $a` for split //, "Æf½ṀḤ<90"'
198: 2 3 3 11
102: 2 3 17
189: 3 3 3 7
7744: 2 2 2 2 2 2 11 11
7716: 2 2 3 643
60: 2 2 3 5
57: 3 19
48: 2 2 2 2 3

Sayı olarak ayrıştırılan tek belirteç 90. Hiçbiri 9, 0ve 90asal vardır.

açıklama

Buradaki temel matematiksel içgörü, 45²'nin 2017 (mevcut yıl) ile 2027 (bir sonraki başbakan) arasında düzgün bir şekilde düşen 2025 olduğunu göstermektedir. Böylece, sayının her asal çarpanının karekökünü alabilir ve herhangi bir 45'i geçip geçmediğine bakabiliriz. Ne yazık ki, 45değişmezden dolayı yazamayız 5, bu yüzden onu ikiye katlamalı ve bunun yerine 90 ile karşılaştırmalıyız.

Æf½ṀḤ<90
Æf        In the list of prime factors,
  ½       taking the square root of each element
   Ṁ      then taking the largest element
    Ḥ     and doubling it
     <90  produces a result less than 90.

Mathematica, 62 58 55 bayt

Kaydedilen son üç bayt tamamen Martin Ender!

#4<4||#<44*46&&#6[#^-1#4]&[Divisors[#][[6-4]],,,#,,#0]&

Adsız işlev, pozitif bir tamsayı argümanı alarak Trueveya döndüren veya False.

Özyinelemeli algoritma, #4<4truthy base case olması ile (sadece imput 1'e geri dönmemiz gerekir True, fakat ekstra base case'ler iyidir). Aksi takdirde, girdilerin en küçük ikinci bölenini (zorunlu olarak asal olan) hesaplar Divisors[#][[6-4]]; eğer 2024 den 's büyüktür ( 44*46) o zaman ile çıkmak Falseaksi takdirde biz (kullanarak yinelemeli işlevini çağırmak, #6hiç set #0bu küçük asal faktör bölü girişine) #(biz olarak ifade etmek zorunda #^-1kez girdi #4beri, /izin verilmese).

Yapısal olarak, ilk yarı #4<4||#<44*46&&#6[#^-1#4]&altı bağımsız değişken anonim fonksiyonudur, bağımsız değişken ile çağrılan Divisors[#][[6-4]], Null, Null, #, Null, ve #0; Bu karakterler yasağı etrafında elde etmektir 2, 3ve 5.

Değiştirerek dört bayt kaydedildi Önceki sürümü, 8018-6000ile 44*46esinlenerek, ais523 en Jelly cevap (Martin Ender de ais523 açıklama esinlenerek gibiydi):

#<4||Divisors[#][[6-4]]<44*46&&#0[Divisors[#][[6-4]]^-1#]&

Bu oldukça iğrençti: Hala bu kısıtlamalar altında Mathematica'da bir değişken ayarlamanın bir yolunu hala bilmiyorum! Hem =ve eiçinde Setizin verilmez. Kaçınılması +ve )aynı zamanda bir sorun olduğu, ancak daha fazla bayt pahasına çalışmak için çok zor değil.

Haskell, 48 47 bayt

\n->[snd$[product[1..44*46]^n]!!0`divMod`n]<[1]

Temel olarak Dennis'in Jelly cevabının çevirisi . xnor bir bayt kaydetti.

Kullanımları […]!!0parantez gibi çünkü )yasaklandı ve snd+ divModçünkü miçinde modve remyasak.

Pyke, 10 8 7 9 bayt

P_Z|hwMX<

Burada dene!

Dennis'in 2025 üretme yöntemini kullanarak 1 bayt kurtarıldı

P         -     factors(input)
 _        -    reversed(^)
  Z|      -   ^ or 0
    h     -  ^[0] or 1
        < - ^ < V
     wM   -  ⁴45 (ord("M")-32)
       X  -  ^**2

Brachylog , 9 10 bayt

*$ph$r*<90

Çevrimiçi deneyin!

Temelde diğer cevabımla aynı algoritmayı kullanmak. $phfirst ( h) ana faktörünü ( $p) bulur ; Brachylog'un ana faktör listeleri en büyüğünden en küçüğüne giderken, bu en büyük ana faktördür. Sonra karekök ( $r), double ( *) alıyorum ve 90 ( <90) ' dan küçük olup olmadığını görmek için test ediyorum .

İlk önce girişi ikiye katlamak zorunda kaldım, çünkü 1 ana faktör yok (ve dolayısıyla birinci ana faktör yok). Bu, bir sayının 2017 gevrek olup olmadığını etkileyemeyen, ancak 1'i kullanırken bir arızayı önleyen, 2'ye ekstra bir ana faktör ekler.

Aslında 9 bayt

τyM:44u²≥

Çok sayıda bayt için Dennis'e teşekkürler!

Çevrimiçi deneyin!

Açıklama:

τyM:44u²≥
τyM        largest prime factor of 2*input (doubled to deal with edge case of n = 1)
   :44u²   2025 (2027 is the next prime after 2017, so any number in [2017, 2026] can be used here - 2025 is very convenient)
        ≥  is 2025 greater than or equal to largest prime factor?

Mathematica, 66 74 bayt

Bunun U+F4A1yasak olduğunu belirttiği için Dennis'e teşekkürler .

Fold[Function[{x,d},And[x,Tr[Divisors@d^0]>6-4||d<44*46]],0<1,Divisors@#]&

Açıklama:

Divisors@#: İlk argüman tamsayı bölenlerin listesi #.

0<1: Golf for True(aynı zamanda mektubu kullanmaktan da kaçınır e).

Divisors@d^0: {1, 1, ..., 1}Bölenlerin sayısına eşit uzunluktaki formun listesi d.

Tr: Düz bir liste Triçin o listenin toplamını döndürür. Böylece Tr[Divisors@d^0]bölenlerin sayısını döndürür d.

Function[{x,d},And[x,Tr[Divisors@d^0]>6-4||d<44*46]]: İki argüman xve isimsiz fonksiyon d. Buradaki fikir dbir bölendir #ve bileşik olup olmadığını 2017(dahil) veya buna eşit veya daha az olduğunu görmek için test ederiz . 2017- gevreklik bu durumu sağlayan tüm bölenlere eşdeğerdir. Ais523'te keşfedildiği gibi, asaldan daha küçük veya ona eşit bir asal olmak, asaldan daha az bir asal olmaya 2017eşdeğerdir 2025. As Greg Martin işaret, o daha küçük olup olmadığının testi yeterlidir 2024=44*46. Argüman x, şu ana kadar karşılaşılan tüm bölenlerin bu özelliği sağlayıp sağlamadığına ilişkin bir akümülatör görevi görür. Daha sonra Foldbu işlevi #başlangıç ​​değeri olan tüm bölenlerin arasından bıraktık.TrueÇünkü ne Mapde erişim hakkımız yok /@.

05AB1E , 10 bayt

fθ46n99-›È

True ise 1, aksi takdirde 0 döndürür.

Çevrimiçi deneyin!

açıklama

f          # Push the list of prime factors (ordered)
 θ         # Get the last element
  46n99-   # Push 2017 (46² - 99)
        >  # Push 1 if the last prime factor is greater than 2017, 0 otherwise
         È # Is the resulting number even ? Transforms 1 to 0 and 0 to 1.
           # Implicit display

MATL , 15 bayt

t:\~ftZp*44QU<A

02017-gevrek olmayan veya 2017-gevrek olmayan çıkışlar 1.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Bu program tüm baytların kompozit olduğunu kontrol eder.

açıklama

t       % Implicit input n. Duplicate
:       % Range [1 2 ... n]
\       % Modulo. Gives 0 for divisors of n
~f      % Indices of zero values
t       % Duplicate
Zp      % Is-prime. Gives 1 for primes, 0 for composites
*       % Multiply
44QU    % 44, add 1, square: 2025
<       % Less than, element-wise
A       % True (1) if all entries are nonzero

Bash, 144 bayt

ASCII kodlaması:

{
printf '[ '
`tr D-Z _-z <<<KFH`tor $1|tr -d :|`tr B-Z _-z <<<JUH`p -o '[0-9]*$'
printf ' -lt $[24*86-46] ]'
}|tr \\n \ |`tr B-Z _-z <<<EDVK`

Kabukta olduğu gibi, çıkış kodu başarı (0) veya başarısızlığı (0 olmayan) gösterir.

Bu etkili bir şekilde farklı bir hecelemedir

[ factor $1|tr -d :|grep -o '[0-9]*$' -lt 2018 ]

En büyük faktörü biz alıyoruz factor $1|grep -o '[0-9]*$'; tr -d :giriş for = özel durum için 1.

İfade $[6*6*69-466]2018 olarak değerlendirilir.

trKomut adları için kullanmak zordu ve hala komut ikameini kullanmak zordu - Yuvalama formunu kullanamadım $( ), bu yüzden sonucu değerlendirmek için başka bir Bash'e geçtim.

Test sonuçları:

$ for i in 1 2 80 2017 2019 2027 11111 45183 102349 999999 1234567 4068289; do printf '%d %s\n' $i `./105241.sh $i  && echo true || echo false`; done
1 true
2 true
80 true
2017 true
2019 true
2027 false
11111 true
45183 false
102349 false
999999 true
1234567 false
4068289 true

Karakter kodlarının doğrulanması:

$ grep -v '^#' ./105241.sh | perl -n -Mutf8 -E '$a = ord, print `factor $a` for split //, $_' | grep -v ': .* ' | wc -l
0

Pyth, 11 bayt

!s>R^h44h1P

Çevrimiçi deneyin. Test odası.

Dennis'in numarasını 2025 almak için kullanır , daha sonra girdilerin temel faktörlerinin daha büyük olup olmadığını kontrol eder.

Julia 0.4 , 84 38 37 bayt

n->1^n:44*46|>prod|>t->t^n-t^n÷n*n<1

Bir BigInt'ı argüman olarak bekler .

Çevrimiçi deneyin! veya hiçbir baytın asal olmadığını doğrulayın .

Japt , 14 bayt

k æ¨44*46 ?0:1

True ise 1, false 0 döndürür.

Burada dene .

Braingolf , 11 bayt [çok rekabetçi]

VRp#ߢ-?0:1

Çevrimiçi deneyin!

ߢBununla birlikte, sayıları olan vidalar nedeniyle okunamaz , ancak yine de bir tercümanda çalışır.

Bunu yazarken karakter kısıtlamalarını bile fark etmedim, ama tek yapmam gereken garip unicode karakterini 2017'den 2018'e değiştirmek oldu.

Verilen 2018 bir asal değildir <= 2018, aynı zamanda herhangi bir asaldır.<= 2017

açıklama

VRp#ߢ-?0:1  Implicit input from command-line args
VR            Create stack2, return to stack1
  p           Split last item into prime factors, push each one to stack in asc order
   #ߢ         Push 2018
     -      Subtract last 2 items (highest prime factor - 2017)
      ?     If last item > 0..
       0    ..push 1
        :   Else..
         1  ..Push 1
            Implicit output of last item on stack