Girdi olarak pozitif bir tamsayı verildiğinde, bunun çok büyük sayı olup olmadığını belirleyin.

Magnanimous bir sayı, +10 tabanındaki herhangi iki hane arasına herhangi bir işaret eklendiğinde, asal bir tamsayı ifadesiyle sonuçlanacak bir sayıdır.

Örneğin, 40427, çünkü çok büyük.

4+0427  = 431  is prime
40+427  = 467  is prime
404+27  = 431  is prime
4042+7  = 4049 is prime

Çıktı

Girdi büyük, diğeri giriş olmadığında iki farklı değer vermelisiniz.

puanlama

Bu yarışmanın amacı, bayt olarak verilen bu görevi çözmek için yazılmış kaynak kodun boyutunu mümkün olduğunca küçük hale getirmektir.

Test Kılıfları

1       -> True
2       -> True
4       -> True
10      -> False
98      -> True
101     -> True
109     -> False
819     -> False
4063    -> True
40427   -> True
2000221 -> True

OEIS 253996

05AB1E , 10 bayt

kod

η¨¹.s¨R+pP

05AB1E kodlamasını kullanır . Çevrimiçi deneyin! veya Tüm test durumlarını doğrulayın!

açıklama

η¨             # Take the prefixes of the input and remove the last element
  ¹.s¨         # Take the suffixes of the input and remove the last element
      R        # Reverse the array of suffixes
       +       # Vectorized addition
        p      # Check if each element is prime
         P     # Product of the array

C (gcc) , 8384 85 83 84 86 75 111 bayt

Tüm optimizasyonlar kapatıldı ve yalnızca GCC 32 bitinde.

@Ceilingcat sayesinde -1 bayt

+ 1durum için bazı baytlar .

+ tekrar kullanılabilir fonksiyonlar için bazı baytlar.

i,j,r,s;f(a){for(i=10,r=1;a/i;i*=10)for(s=a%i+a/i,r*=s-1,j=2;j<s;)r*=s%j++>0;a=!r;}

Bir tamsayı olarak girdi alır. Yanlış durumlar için 1, gerçek durumlar için 0 döndürün.

Çevrimiçi deneyin!

Mathematica kodu (55 bayt) için başka bir cevaba bakınız.

Retina , 38 bayt

\B
$`$*_$'$*_
S`\d
G`^_$|^(__+)\1+$
^$

Çevrimiçi deneyin!

Büyük 1sayılar için basar ve 0başka türlü.

açıklama

\B
$`$*_$'$*_

Her pozisyonu iki hane arasında eşleştirerek (kelime sınırı olmayan pozisyonlar) ve _unary basamağını kullanarak unary'de eşleşmenin hem önekini hem de sonekini ekleyerek başlıyoruz . Böylece +s eklemek yerine, oradaki toplamın tekli sonucunu doğrudan ekliyoruz.

S`\d

Şimdi dizgiyi rakamların etrafına böldük, böylece her toplam kendi satırında gider ve bu rakamlardan kurtuluruz (ayrıca boş bir satır ve son satır olacak, ama bu önemli değil).

G`^_$|^(__+)\1+$

Bu, asal olmayan sayıların aynı miktarlarda eşleşmesi için kullanılan standart regex'tir. GBurada bir rep aşaması kullanmak , pozitif astar içermeyen tüm çizgileri (boş çizgileri atarak) tutmamız anlamına gelir.

^$

Sonunda dizginin boş olup olmadığını kontrol ediyoruz. Girdi çok büyük olsaydı, önceki aşama tüm satırları atmış olacaktı (çünkü hepsi asal idi) ve bu bize veriyor 1. Aksi takdirde, herhangi bir satır asal değilse, dizgede kalır ve regex başarısız olur 0.

Python 2 , 82 79 78 bayt

f=lambda n,d=10:n<d or d/n<all((n/d+n%d)%k*f(n,10*d)for k in range(2,n/d+n%d))

Bu yavaştır ve yalnızca not alan test durumlarıyla başa çıkabilir.

Çevrimiçi deneyin!

Alternatif versiyon, 79 bayt

f=lambda n,d=10:n<d or f(n,10*d)>d/n<all((n/d+n%d)%k for k in range(2,n/d+n%d))

Bir bayt pahasına hızlandı.

Çevrimiçi deneyin!

Jöle , 12 bayt

DJ⁵*⁸dṖS€ÆPẠ

Çevrimiçi deneyin!

Tüm test durumlarını doğrulayın.

Java 8, 175 171 94 88 bayt

n->{long d=10,r=0,i,t;for(;d<=n;d*=10,r|=t-i)for(t=n/d+n%d,i=1;t%++i%t>0;);return r==0;}

-77 @PeterTaylor sayesinde bir aritmetik (String yerine .substring) kullanmak ve tamsayının asal olup olmadığını kontrol etmek için ayrı metottan kurtulmak. @SaraJ
kullanarak -6 bayt 'ın denetleme yöntemini , bu yüzden onu yendiğinizden emin olun!

Burada dene.

Açıklama:

n->{                  // Method with long as both parameter and return-type
  long d=10,r=0,i,t;  //  Some temp longs
  for(;d<=n           //  Loop as long as `d` is below or equal to input `n`
                      //  (inclusive instead of exclusive due to special case 10)
      ;               //    After every iteration:
       d*=10,         //     Multiple `d` by 10
       r|=t-i)        //     and Bitwise-OR `r` with `t-i`
    for(t=n/d+n%d,    //   Set `t` to `n` integer-divided by `d` plus `n` modulo-`d`
        i=1;          //   Set `i` to 1
        t%++i%t>0;);  //   Inner oop as long as `t` modulo `i+1` modulo `t` is not 0 yet
                      //   (after we've first increased `i` by 1 with `++i`)
                      //   (if `t` equals `i` afterwards, it means `t` is a prime)
  return r==0;}       //  Return if `r` is still 0

Pyth , 14 bayt

.AmP_ssMcQ]dtU

Çevrimiçi deneyin! TrueSayının çok büyük olup olmadığını gösterecektir ,FalseAksi taktirde . Sayıyı dize olarak alır.

açıklamalar

.AmP_ssMcQ]dtU

              Q    # Implicit input Q
            tU     # Generate the range [1, 2, ..., len(Q)-1]
  m                # For each index d in the above range...
        cQ]d       # Split Q at index d
      sM           # Convert the two parts to integers
     s             # Sum
   P_              # Check it is a prime
.A                 # ...end for. Check all elements are True

Python 2 , 104 102 98 96 103 bayt

• 2 baytlık @Wheat Wizard sayesinde: isadece bir kez çağrıldığından beri tamamen isimsiz yapıldı .
• 4 byte için @Hyperneutrino sayesinde: dilimleme yerine ana numaradan sayıları almanın daha akıllıca yolu
• @Hyperneutrino 2 bayt daha kaydetti: x-1sadece xbirinci sınıf kontrol için.
• Dava x=10sorunu giderildi , bu nedenle 7 Bayt eklendi; @Dennis ve @Wheat Wizard'ı tespit etmek için: Önceki sürümüm 1'i birinci görmüştü.

lambda x:all((lambda x:x>1and all(x%j for j in range(2,x)))(x/10**j+x%10**j)for j in range(1,len(`x`)))

Çevrimiçi deneyin!

Japt , 24 16 bayt

Bu hemen hemen @Shaggy, @ETHproduction ile benim aramızdaki bir işbirliğiydi.

¬£[YîU UtY]xÃÅej

Çevrimiçi deneyin!

Bir dize olarak girdi alır.

Pip , 25 24 bayt

$&0N_%,_=1M$+(a^@_)M1,#a

Çevrimiçi deneyin!

açıklama

ailk komut satırı argümanıdır. 1,#aSayı içeren bir Range üretir 1aracılığıyla len(a)-1. Bunun için bir lambda fonksiyonunu eşleriz:

$+(a^@_)
   a^@_   Split a at this index
$+(    )  Fold the resulting 2-element list on +

Sonra, 0N_%,_=1önceliği test eden başka bir lambda fonksiyonunun haritasını çıkardık. Bu cevaptan aldım ; orada açıklama okuyabilirsiniz. Sonunda, listeyi mantıksal AND ( $&) üzerine katlıyoruz . Sonuçta 1, 0eğer biri olmasaydı , tüm meblağlar asal idi.

Örnek, girişi ile 4063:

                    1,#a   [1; 2; 3]
           $+(a^@_)M       [67; 103; 409]
  0N_%,_=1M                [1; 1; 1]
$&                         1

CJam , 22 bayt

r:L,({)_L<i\L>i+mp!},!

Çevrimiçi deneyin!

Gerçeklik için pozitif tamsayı, sahte için sıfır olanı yazdırır.

-1 Peter Taylor'ın zekice bir numarası sayesinde .
-3 Peter Taylor tarafından başka bir ipucu sayesinde.

Japt , 23 bayt

Bir dize olarak girdi alır.

Dang; üzerinde çalıştığım çok daha kısa bir alternatifle yumruk attı .

£i+Ýe@OxXr"%+0+"'+)j

Dene

Mathematica, 75 bayt

And@@Table[PrimeQ@ToExpression@StringInsert[#,"+",n],{n,2,StringLength@#}]&

Functionhangisi bekliyor String? th basamağından sonra bir harfin asıl sayı PrimeQ@ToExpression@StringInsert[#,"+",n]verip vermeyeceğini döndürür . Bu değerlerin listesini dizenin uzunluğuna kadar uzanır . Sonra o listenin öğelerinin her birini alırız. Uygun bir şekilde, eğer öyleyse , boş liste+nTable[...,{n,2,StringLength@#}]n2AndStringLength@#<2Table[...]And@@{}==True

Mathematica, 55 50 45 49 50 54 62 bayt

Ayrı ayrı göndermem gerekiyor gibi görünüyor.

Tekrar ölçülen kod uzunluğu için +6 bayt.

Ngenisis sayesinde +5 bayt.

And@@(qPrimeQ[#~Mod~q+⌊#/q⌋])@Rest@PowerRange@#&

Bir tamsayı olarak girdi alır ve düzenli döndürür Trueve False. Aradaki , unicode 0xF4A1, kısacası Function[,]. Kod uzunluğu dosya boyutunda (BOM olmadan UTF-8) ölçülür, doğru değilse yorum yapın.

PowerRange[x]10, 100 ... den büyük değil x, Mathematica 10'da tanıtılanlardan daha büyük .

Düz İngilizce 4.204 341 315 251 241 240 bayt

(Re-) 3.863 byte'ı Plain English'in kütüphanesine taşıyarak Plain English'in kütüphanesine ilkellik testini dahil etti. 26 bayt beyaz boşluk silindi. Yerel değişkenleri kısaltarak 64 bayt kurtarıldı. Arayüzü kısaltmak suretiyle 10 bayt kaydedildi. Başına RosLuP bireyin öneri, m başlatıldı ve artırılır nasıl değiştirerek 1 byte kurtardı.

To decide if a n number is g:
Put 1 in a m number.
Loop.
Multiply the m by 10.
If the m is greater than the n, say yes.
Divide the n by the m giving a q quotient and a r remainder.
Add the q to the r.
If the r is not prime, say no.
Repeat.

Son kodun ungolfed versiyonu:

To decide if a number is magnanimous:
  Put 1 in another number.
  Loop.
    Multiply the other number by 10.
    If the other number is greater than the number, say yes.
    Divide the number by the other number giving a quotient and a remainder.
    Add the quotient to the remainder.
    If the remainder is not prime, say no.
  Repeat.

Notlar: Düz İngilizce IDE'yi github.com/Folds/english adresinde bulabilirsiniz . IDE, Windows üzerinde çalışır. 32-bit x86 kodunu derler.

Osmosian al Düz İngilizce 'nin dinamik çatal zaten sürümü 4700 yılında test asallık vardı, ama (Haziran 2017 ile Ocak itibariyle) çok verimsiz bir algoritma kullanılır. GitHub sitesinin dinamik çatalının 4001-4011 sürümleri ilkellik testini çıkardı. GitHub sitesinin dinamik çatalının 4013 sürümü, öncelik testini içeriyor. Asallık testini gerçekleştirecek kod, bu cevabın önceki revizyonlarının bir parçası olarak geliştirilmiştir.

Perl 6 , 58 bayt

{?(10,10* *...^*>$_).map({$_ div$^a+$_%$^a}).all.is-prime}

Çevrimiçi deneyin!

10, 10 * * ...^ * > $_giriş parametresini geçen öğeden bir öncekine kadar alınan on katın geometrik dizisidir $_. Daha sonra, her on güç için, div ve mod alınan giriş parametresinin toplamının, bu gücün asal olduğunu kontrol ederiz.

Haskell, 114 110 bayt

p x=[x]==[i|i<-[2..x],x`mod`i<1]
i!x|i<1=0<1|0<1=p(uncurry(+)$divMod x$10^i)&&(i-1)!x
f x=(length(show x)-1)!x

Açıklama ile Ungolfed:

-- Check if x is a prime number
p x = [x] == [i | i<-[2..x], x`mod`i < 1]
-- Checks all pairs of numbers a '+' can be put in between
i ! x | i<1 = 0<1                                -- Single-digit numbers are always truthy
      | 0<1 = p (uncurry (+) $ divMod x $ 10^i)  -- Does x split at i digits from right sum up to a prime?
           && (i-1) ! x                          -- If so, check next pair
-- Start (!) with the number of digits in x minus one
f x = (length (show x)-1) ! x

Aksiyom, 88 bayt

f(n:PI):Boolean==(i:=10;repeat(q:=n quo i;q=0 or ~prime?(q+n rem i)=>break;i:=i*10);q=0)

test ve sonuçlar

(10) -> [[i,f(i)]  for i in [1,2,4,10,98,101,109,819,4063,40427,2000221,999999999999999999999999999999999999999999999]]
   (10)
   [[1,true], [2,true], [4,true], [10,false], [98,true], [101,true],
    [109,false], [819,false], [4063,true], [40427,true], [2000221,true],
    [999999999999999999999999999999999999999999999 ,false]]

Brachylog , 11 bayt

{~cĊℕᵐ+}ᶠṗᵐ

Çevrimiçi deneyin!

{      }ᶠ      Find every
      +        sum of
   Ċ           two
    ℕᵐ         whole numbers
 ~c            which concatenate to the input,
          ᵐ    and assert that all of them
         ṗ     are prime.

Perl 6 , 35 bayt

{m:ex/^(.+)(.+)$/.all.sum.is-prime}

Çevrimiçi deneyin!

Açıklama:

{                                 }     # Anonymous code block that
 m:ex/^        $/                         # Match all
       (.+)(.+)                           # Splits of the input number
                 .all                     # Are all of them
                     .sum                   # When summed
                         .is-prime          # Prime?

Yığılmış , 51 bayt

[tostr:#'1-~>splitat tr['+',' '#`#~prime]map 1,all]

Çevrimiçi deneyin!

Bu bir fonksiyondur. Argümanını bir dizgeye ( tostr) dönüştürerek , çoğaltarak ve uzunluğunu ( :#') alarak, 1 ( 1-) 'i çıkartarak , 1'den o sayıya ( ~>) kadar bir aralık oluşturarak çalışır . Yığın girişi için böyle bir şey görünüyor 40427:

('40427' (1 2 3 4))

splitatAşağıdaki dizinin yığının en üstünde olmasıyla sonuçlanan vectorized gerçekleştiriyoruz :

(('4' '40' '404' '4042') ('0427' '427' '27' '7'))

Bu transposing ile tr, biz alırız:

(('4' '0427') ('40' '427') ('404' '27') ('4042' '7'))

Ardından ['+',' '## ~ prime] (withmap`) fonksiyonunu eşleriz. Bu fonksiyon şunları yapar:

['+',' '#`#~prime]
 '+',                concatenate a plus sign (string)    `('4' '0427' '+')
     ' '#`           join by spaces                      `'4 0427 +'`
          #~         evaluate                            `431`
            prime    check primality                     `1`

Sonra haritanın ardından birleştirdik 1. Bu boş bir liste için alldöndüğünden beri undef.

JavaScript (ES6), 70 bayt

P=(n,x=2)=>n%x?P(n,x+1):n==x
f=(n,i=10)=>i>n||P((n/i|0)+n%i)&f(n,i*10)

Tarayıcımdaki son davada hesaplama yaparken "çok fazla özyineleme" hatası nedeniyle başarısız oluyor P(200023). Umarım bu onu geçersiz kılmaz.

QBIC , 38 bayt

_L;|[a-1|q=q*µ!_sA,b|!+!_sA,b+1,a|!}?q

açıklama

_L |     Create a variable a and set it to the length of
  ;      the input string (A$)
[a-1|    FOR b = 1 to a-1
q=q*     multiply q by
 µ       -1 if prime, 0 if not, of
  !        a cast of 
   _s       a substring of
     A,       A$
     b        from index 1 to index b (only one index is given, so that is assumed to be the req. length from 1)
      |!   to number
 +         plus
 !         a cast of
  _s         a substring of
    A,         A$
    b+1        from index b+1
    ,a         for the length of a (does not error if it exceeds the end of the string)
      |!   to number
 }       NEXT 
 ?q      PRINT q, which is eitrher -1 or 1 for all-prime sums, or 0 otherwise

CJam (21 bayt)

r:R,({RiA@)#md+mp!},!

Çevrimiçi demo , çevrimiçi test paketi

teşrih

r:R       e# Take a token of input and assign it to R
,(        e# Take the length of R minus one
{         e# Filter i = 0 to (length of R minus two)
  Ri      e#   Push R as an integer value
  A@)#    e#   Push 10 to the power of (i + 1)
  md      e#   divmod
  +mp!    e#   Add, primality test, negate result
},        e# The result of the filter is a list of splits which give a non-prime
!         e# Negate result, giving 0 for false and 1 for true

Pyth, 15 14 bayt

.AmP_svcz]dtUz

Test odası

Pyth'in en yeni değişikliğini kullanarak bir bayt kaydedildi.

APL (NARS), karakter 35, bayt 70

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}

Ölçek:

  f←{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
  f¨1 2 4 10 98 101 109 819 4063 40427 2000221
1 1 1 0 1 1 0 0 1 1 1 

Bu APL’de Axiom post algo’dan tercüme olur.

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
 0≥k←¯1+≢⍕⍵:1⋄  assign to k the length as array of argument return 1 if that is <=0
 ∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k
              m←10*⍳k  m is the array pow(10,1..k)
           ⌊⍵÷m       the array of quotient of argumet with m
          +           sum 
     (m∣⍵)            with array of remander
   0π                 build the binary array of "are prime each"
 ∧/                   and that array

PHP, 100 bayt

for(;++$k<strlen($a=$argn);$x+=$i==1)for($i=$n=substr($a,$k)+$b.=$a[$k-1];--$i&&$n%$i;);echo$x+2>$k;

1girişin büyük olması durumunda yazdırır, değilse boş çıktı. Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

Perl 5 -p , 42 bayt

$\=1;s//map$\&&=($`+$')%$_,2..$`+$'-1/ge}{

Çevrimiçi deneyin!