Diberikan bilangan bulat positif sebagai input menentukan apakah itu bilangan murah hati.

Bilangan murah hati adalah angka sedemikian rupa sehingga setiap penyisipan +tanda antara dua digit pada basis 10 menghasilkan ekspresi bilangan bulat utama.

Misalnya 40427 adalah murah hati karena

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

Keluaran

Anda harus menampilkan dua nilai yang berbeda, satu ketika input murah hati dan satu ketika input tidak.

Mencetak gol

Tujuan dari kontes ini adalah untuk membuat ukuran kode sumber yang ditulis untuk menyelesaikan tugas ini, diberikan dalam byte, sekecil mungkin.

Uji Kasus

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 byte

Kode

η¨¹.s¨R+pP

Menggunakan penyandian 05AB1E . Cobalah online! atau Verifikasi semua kasus uji!

Penjelasan

η¨             # 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 byte

Semua optimasi dimatikan dan hanya pada GCC 32-bit.

-1 byte terima kasih kepada @ceilingcat

+ beberapa byte untuk 1case.

+ beberapa byte untuk fungsi yang dapat digunakan kembali.

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

Mengambil input sebagai integer. Kembalikan 1 untuk kasus palsu, 0 untuk kasus nyata.

Cobalah online!

Lihat jawaban saya yang lain untuk kode Mathematica (55 byte).

Retina , 38 byte

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

Cobalah online!

Mencetak 1untuk angka murah hati dan 0sebaliknya.

Penjelasan

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

Kami mulai dengan mencocokkan setiap posisi antara dua digit (posisi yang bukan batas kata) dan memasukkan awalan dan akhiran yang cocok dengan unary, menggunakan _sebagai digit unary. Jadi alih-alih memasukkan +s, kami langsung memasukkan hasil unary dari jumlah di sana.

S`\d

Sekarang kita membagi string di sekitar digit, sehingga setiap jumlah berjalan pada barisnya sendiri dan kita menyingkirkan digit-digit itu (akan ada juga baris awal dan akhir yang kosong, tetapi itu tidak penting).

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

Ini adalah regex standar untuk mencocokkan nomor non-prime di unary. Menggunakan Gtahap rep di sini berarti kita hanya menyimpan semua baris yang berisi non-bilangan prima positif (membuang baris kosong).

^$

Akhirnya kami memeriksa apakah string kosong. Jika input murah hati, tahap sebelumnya akan membuang semua baris (karena semuanya adalah bilangan prima), dan ini memberi kita1 . Kalau tidak, jika ada baris yang bukan bilangan prima, itu akan tetap di string dan regex gagal, memberi 0.

Python 2 , 82 79 78 byte

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

Ini adalah lambat dan hanya bisa mengatasi kasus uji dengan memoisasi.

Cobalah online!

Versi alternatif, 79 byte

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

Mempercepat dengan biaya satu byte.

Cobalah online!

Jelly , 12 byte

DJ⁵*⁸dṖS€ÆPẠ

Cobalah online!

Verifikasi semua kasus uji.

Java 8, 175 171 94 88 byte

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 terima kasih kepada @PeterTaylor dengan menggunakan aritmatika (bukan String dengan .substring) dan menyingkirkan metode terpisah untuk memeriksa apakah integer adalah bilangan prima.
-6 byte menggunakan metode pengecekan utama @SaraJ , jadi pastikan untuk meningkatkannya!

Coba di sini.

Penjelasan:

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 byte

.AmP_ssMcQ]dtU

Cobalah online! Akan ditampilkan Truejika nomornya murah hati, Falsejika tidak. Mengambil nomor sebagai string.

Penjelasan

.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 byte

• Terima kasih kepada @Wheat Wizard untuk 2 byte: dibuat isepenuhnya anonim karena hanya dipanggil sekali.
• Berkat @Hyperneutrino untuk 4 byte: cara yang lebih cerdas untuk mendapatkan angka dari nomor utama alih-alih mengiris
• @Hyperneutrino menyimpan 2 byte lagi: x-1 hanya xuntuk pengecekan prime rarnge.
• Memperbaiki kegagalan untuk case x=10, dengan demikian menambahkan 7 Bytes, terima kasih kepada @Dennis dan @Wheat Wizard untuk melihatnya: versi saya sebelumnya mempertimbangkan 1 sebagai prime

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

Cobalah online!

Japt , 24 16 byte

Ini adalah kolaborasi antara @Shaggy, @ETHproduction, dan saya sendiri.

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

Cobalah online!

Mengambil input sebagai string.

Pip , 25 24 byte

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

Cobalah online!

Penjelasan

aadalah argumen baris perintah pertama. 1,#amenghasilkan Rentang yang berisi angka 1melalui len(a)-1. Untuk ini, kami memetakan fungsi lambda:

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

Selanjutnya, kami memetakan fungsi lambda lain 0N_%,_=1,, yang menguji primality. Saya mengambilnya dari jawaban ini ; Anda bisa membaca penjelasannya di sana. Akhirnya, kita lipat daftar pada logika AND ( $&). Hasilnya adalah1 jika semua jumlahnya prima, 0jika ada yang tidak.

Contoh, dengan input dari 4063:

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

CJam , 22 byte

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

Cobalah online!

Mencetak bilangan bulat positif untuk kebenaran, nol untuk falsy.

-1 berkat trik pintar oleh Peter Taylor .
-3 Berkat tip lain oleh Peter Taylor.

Japt , 23 byte

Mengambil input sebagai string.

Gantung itu; dipukuli dengan pukulan pada alternatif yang jauh lebih pendek yang saya kerjakan.

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

Menguji

Mathematica, 75 byte

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

Functionyang mengharapkan a String.PrimeQ@ToExpression@StringInsert[#,"+",n]mengembalikan apakah memasukkan +setelah ndigit th memberikan angka prima. Table[...,{n,2,StringLength@#}]memberikan daftar nilai-nilai ini sebagai nrentang dari 2panjang string. Kami kemudian mengambil Andmasing-masing elemen dari daftar itu. Mudah, jika StringLength@#<2, maka Table[...]adalah daftar kosong, untuk ituAnd@@{}==True

Mathematica, 55 50 45 49 50 54 62 byte

Sepertinya saya harus mempostingnya secara terpisah.

+6 byte untuk panjang kode yang diukur ulang.

+5 byte berkat ngenisis.

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

Mengambil input sebagai integer dan mengembalikan reguler Truedan False. Di antara keduanya adalah unicode 0xF4A1, kependekan dari Function[,]. Panjang kode diukur pada ukuran file (UTF-8 tanpa BOM), beri komentar jika tidak benar.

PowerRange[x]mengembalikan 1, 10, 100 ... tidak lebih besar dari x, yang diperkenalkan di Mathematica 10.

Bahasa Inggris Biasa 4.204 341 315 251 241 240 byte

(Re-) memasukkan pengujian awal ke perpustakaan Plain English, dengan memindahkan 3.863 byte ke perpustakaan Plain English. Menghapus ruang putih 26 byte. Disimpan 64 byte dengan menyingkat variabel lokal. Disimpan 10 byte dengan menyingkat antarmuka. Sesuai saran RosLuP , disimpan 1 byte dengan mengubah cara m diinisialisasi dan bertambah.

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.

Versi final kode akhir:

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.

Catatan: Plain English IDE tersedia di github.com/Folds/english . IDE berjalan pada Windows. Ini mengkompilasi ke kode x86 32-bit.

The Osmosian Orde 's dinamis garpu dari Plain English sudah primality menguji dalam versi 4700, tetapi menggunakan algoritma yang sangat tidak efisien (seperti dari Januari sampai Juni 2017). Versi 4001-4011 dari garpu dinamis dinamis situs GitHub dihilangkan dari pengujian keaslian. Versi 4013 dari garpu dinamis situs GitHub mencakup pengujian awal. Kode untuk melakukan pengujian awal dikembangkan sebagai bagian dari revisi sebelumnya atas jawaban ini.

Perl 6 , 58 byte

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

Cobalah online!

10, 10 * * ...^ * > $_ adalah urutan geometri kelipatan sepuluh, diambil hingga satu sebelum elemen yang melebihi parameter input $_ . Kemudian kita hanya memeriksa bahwa untuk setiap kekuatan sepuluh, jumlah parameter input yang diambil div dan mod daya yang utama.

Haskell, 114 110 byte

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

Tidak digabungkan dengan penjelasan:

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

Aksioma, 88 byte

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)

tes dan hasil

(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 byte

{~cĊℕᵐ+}ᶠṗᵐ

Cobalah online!

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

Perl 6 , 35 byte

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

Cobalah online!

Penjelasan:

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

Ditumpuk , 51 byte

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

Cobalah online!

Ini sebuah fungsi. Ia bekerja dengan mengonversi argumennya menjadi string ( tostr), menduplikasinya dan mendapatkan panjangnya ( :#'), mengurangi 1 ( 1-), membuat rentang dari 1 ke angka itu ( ~>). Tumpukan terlihat seperti ini, untuk input 40427:

('40427' (1 2 3 4))

Kami melakukan vektorisasi splitat, menghasilkan array berikut berada di bagian atas tumpukan:

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

Dengan memindahkan ini tr, kita mendapatkan:

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

Kemudian, kami memetakan fungsi ['+',' '## ~ prime] (withmap`). Fungsi ini tidak:

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

Kemudian, setelah peta, kami bergabung 1. Ini karena allpengembalian undefuntuk daftar kosong.

JavaScript (ES6), 70 byte

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)

Gagal pada kasus terakhir di browser saya karena kesalahan "terlalu banyak rekursi" saat menghitung P(200023). Semoga ini tidak membatalkannya.

QBIC , 38 byte

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

Penjelasan

_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 byte)

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

Demo online , online test suite online

Pembedahan

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 byte

.AmP_svcz]dtUz

Suite uji

Menyimpan byte menggunakan perubahan terbaru Pyth.

APL (NARS), karakter 35, byte 70

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

uji:

  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 

Ini akan menjadi terjemahan dalam APL dari Aksioma posting di sini ...

{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 byte

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;

mencetak 1jika input murah hati, mengosongkan output jika tidak. Jalankan sebagai pipa dengan -nRatau coba online .

Perl 5 -p , 42 byte

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

Cobalah online!