รับจำนวนเต็มบวกเป็นอินพุตกำหนดว่าเป็นจำนวนใจกว้าง

หมายเลขใจกว้างคือตัวเลขที่การแทรก+เครื่องหมายใด ๆ ระหว่างตัวเลขสองหลักใด ๆ ในฐาน 10 ส่งผลให้เกิดการแสดงออกของจำนวนเต็มจำนวนเต็ม

ตัวอย่างเช่น 40427 นั้นไม่เห็นด้วยเพราะ

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

เอาท์พุต

คุณควรส่งออกค่าที่แตกต่างกันสองค่าหนึ่งค่าเมื่ออินพุตมีขนาดใหญ่และอีกค่าหนึ่งเมื่ออินพุตไม่

เกณฑ์การให้คะแนน

เป้าหมายของการประกวดครั้งนี้คือการทำให้ขนาดของซอร์สโค้ดถูกเขียนขึ้นเพื่อแก้ปัญหานี้ซึ่งกำหนดเป็นไบต์ขนาดเล็กที่สุดเท่าที่จะเป็นไปได้

กรณีทดสอบ

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 ไบต์

รหัส

η¨¹.s¨R+pP

ใช้การเข้ารหัส05AB1E ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด!

คำอธิบาย

η¨             # 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 ไบต์

การปรับให้เหมาะสมทั้งหมดถูกปิดและใช้กับ GCC 32 บิตเท่านั้น

-1 ไบต์ขอบคุณ @ceilingcat

+ ไบต์บาง1กรณี

+ บางไบต์สำหรับฟังก์ชั่นที่ใช้ซ้ำได้

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

รับอินพุตเป็นจำนวนเต็ม ส่งคืน 1 สำหรับกรณีเท็จ, 0 สำหรับกรณีจริง

ลองออนไลน์!

ดูคำตอบอื่นของฉันสำหรับรหัส Mathematica (55 ไบต์)

เรติน่า , 38 ไบต์

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

ลองออนไลน์!

พิมพ์1สำหรับหมายเลขใจกว้างและ0อื่น ๆ

คำอธิบาย

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

เราเริ่มต้นด้วยการจับคู่แต่ละตำแหน่งระหว่างตัวเลขสองหลัก (ตำแหน่งที่ไม่ใช่ขอบเขตของคำ) และการใส่ทั้งคำนำหน้าและคำต่อท้ายของการจับคู่นั้นในภาษาเดียวกันโดยใช้_เป็นตัวเลขหลัก ดังนั้นแทนที่จะใส่+s เราจะแทรกผลลัพธ์ที่ไม่รวมกันของผลรวมตรงนั้น

S`\d

ตอนนี้เราแบ่งสตริงรอบ ๆ ตัวเลขเพื่อให้ผลรวมแต่ละรายการอยู่ในบรรทัดของตัวเองและเราจะกำจัดตัวเลขเหล่านั้น (จะมีเส้นนำหน้าและบรรทัดว่างเปล่าเช่นกัน แต่นั่นไม่สำคัญ)

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

นี่คือ regex มาตรฐานเพื่อให้ตรงกับตัวเลขที่ไม่สำคัญในเอก การใช้Gตัวแทนขั้นตอนที่นี่หมายความว่าเราเพียงแค่เก็บทุกบรรทัดที่มีค่าบวกบวก (ทิ้งบรรทัดว่าง)

^$

ในที่สุดเราตรวจสอบว่าสตริงว่างเปล่า ถ้าใส่เป็นเอื้อเฟื้อเผื่อแผ่ขั้นตอนก่อนหน้านี้จะได้ทิ้งทุกบรรทัด (เพราะพวกเขาเป็นจำนวนเฉพาะทั้งหมด) 1และสิ่งนี้จะช่วยให้เรา มิฉะนั้นถ้าบรรทัดใด ๆ ไม่ได้เป็นนายกก็จะยังคงอยู่ในสตริงและ regex 0ล้มเหลวให้

Python 2 , 82 79 78 ไบต์

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

สิ่งนี้ช้าและสามารถรับมือกับกรณีทดสอบที่มีการบันทึกความจำเท่านั้น

ลองออนไลน์!

รุ่นสำรอง 79 ไบต์

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

เร่งความเร็วที่ค่าหนึ่งไบต์

ลองออนไลน์!

เยลลี่ 12 ไบต์

DJ⁵*⁸dṖS€ÆPẠ

ลองออนไลน์!

ตรวจสอบกรณีทดสอบทั้งหมด

Java 8, 175 171 94 88 ไบต์

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โดยใช้เลขคณิต (แทนที่จะเป็น String ด้วย.substring) และกำจัดวิธีการแยกต่างหากเพื่อตรวจสอบว่าจำนวนเต็มเป็นจำนวนเฉพาะหรือไม่
-6 ไบต์โดยใช้วิธีการตรวจสอบเฉพาะของ@SaraJดังนั้นอย่าลืม upvote เธอ!

ลองที่นี่

คำอธิบาย:

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 ไบต์

.AmP_ssMcQ]dtU

ลองออนไลน์! จะแสดงTrueหากหมายเลขนั้นไม่เอื้ออำนวยเป็นFalseอย่างอื่น รับจำนวนเป็นสตริง

คำอธิบาย

.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 ไบต์

• ขอบคุณ @Wheat Wizard สำหรับ 2 ไบต์: ทำให้iไม่ระบุชื่อโดยสมบูรณ์เนื่องจากถูกเรียกเพียงครั้งเดียว
• ขอบคุณ @Hyperneutrino สำหรับ 4 ไบต์: วิธีที่ชาญฉลาดในการรับตัวเลขจากหมายเลขหลักแทนที่จะใช้การแบ่งส่วน
• @Hyperneutrino บันทึกอีก 2 ไบต์: x-1เพียงxเพื่อตรวจสอบนายก
• แก้ไขความล้มเหลวของเคสx=10ซึ่งเพิ่ม 7 ไบต์ด้วย @Dennis และ @Wheat Wizard สำหรับการตรวจจับ: รุ่นก่อนหน้าของฉันกำลังพิจารณา 1 ไพรม์

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

ลองออนไลน์!

Japt , 24 16 ไบต์

นี่เป็นความร่วมมือระหว่าง @Shaggy, @ETHproduction และตัวฉันเอง

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

ลองออนไลน์!

รับอินพุตเป็นสตริง

Pip , 25 24 ไบต์

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

ลองออนไลน์!

คำอธิบาย

aเป็นอาร์กิวเมนต์บรรทัดคำสั่งแรก 1,#aสร้างช่วงที่มีหมายเลขผ่าน1 len(a)-1ในการนี้เราแมปฟังก์ชัน lambda:

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

ต่อไปเราจะทำแผนที่แลมบ์ดาอีกฟังก์ชั่น0N_%,_=1นั่นเป็นการทดสอบแบบดั้งเดิม เราเอาไปจากคำตอบนี้ ; คุณสามารถอ่านคำอธิบายที่นั่น สุดท้ายเราพับรายการบนตรรกะ AND ( $&) ผลที่ได้คือ1ถ้าจำนวนเงินทั้งหมดเป็นจำนวนเฉพาะ0ถ้าไม่มีพวกเขาเลย

ตัวอย่างด้วยอินพุต4063:

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

CJam , 22 ไบต์

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

ลองออนไลน์!

พิมพ์จำนวนเต็มบวกสำหรับความจริงศูนย์สำหรับความเท็จ

-1 ขอบคุณเคล็ดลับฉลาดโดยปีเตอร์เทย์เลอร์
-3 ขอบคุณเคล็ดลับอื่นโดย Peter Taylor

Japt 23 ไบต์

รับอินพุตเป็นสตริง

Dang it; พ่ายแพ้ต่อการชกต่อยในทางเลือกที่สั้นกว่ามากที่ฉันกำลังทำอยู่

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

ทดสอบมัน

Mathematica, 75 ไบต์

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

FunctionStringซึ่งคาดว่าจะมี PrimeQ@ToExpression@StringInsert[#,"+",n]ส่งคืนว่าการแทรก+หลังจากตัวเลขnth ให้ตัวเลขเฉพาะหรือไม่ Table[...,{n,2,StringLength@#}]ให้รายการของค่าเหล่านี้เป็นnช่วงจาก2ความยาวของสตริง จากนั้นเราจะAndพิจารณาองค์ประกอบแต่ละอย่างของรายการนั้น สะดวกถ้าStringLength@#<2แล้วTable[...]เป็นรายการที่ว่างเปล่าซึ่งAnd@@{}==True

Mathematica, 55 50 45 49 50 54 62 ไบต์

ดูเหมือนว่าฉันควรโพสต์แยกต่างหาก

+6 ไบต์สำหรับความยาวโค้ดที่วัดขึ้นใหม่

+5 ไบต์ขอบคุณ ngenisis

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

จะเข้าเป็นจำนวนเต็มและการกลับมาปกติและTrue ในระหว่างเป็น Unicode 0xF4A1 สั้น ความยาวโค้ดวัดจากขนาดไฟล์ (UTF-8 ที่ไม่มี BOM) แสดงความคิดเห็นหากไม่ถูกต้องFalseFunction[,]

PowerRange[x]ส่งคืน 1, 10, 100 ... ไม่มากไปกว่าxซึ่งได้รับการแนะนำใน Mathematica 10

ภาษาอังกฤษธรรมดา 4,204 341 315 251 241 240 ไบต์

(Re-) รวมการทดสอบแบบดั้งเดิมเข้ากับห้องสมุดของ Plain English โดยย้าย 3,863 bytes ไปที่ Library ของ Plain English ลบพื้นที่สีขาว 26 ไบต์ บันทึก 64 ไบต์โดยการย่อตัวแปรท้องถิ่น บันทึก 10 ไบต์โดยย่ออินเทอร์เฟซ ตามคำแนะนำของRosLuPให้บันทึก 1 ไบต์ด้วยการเปลี่ยนวิธีการเริ่มต้นและเพิ่มค่า m

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.

รุ่นสุดท้ายของโค้ดที่ไม่ได้บรรจุ:

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.

หมายเหตุ: ในภาษาอังกฤษธรรมดา IDE สามารถใช้ได้ที่github.com/Folds/english IDE ทำงานบน Windows มันรวบรวมรหัส x86 แบบ 32 บิต

Osmosian สั่งซื้อ 's ส้อมแบบไดนามิกของภาษาอังกฤษธรรมดาแล้วมี primality ทดสอบในรุ่น 4700 แต่ก็ใช้อัลกอริทึมที่ไม่มีประสิทธิภาพมาก ( ณ เดือนมกราคมถึงมิถุนายน 2017) รุ่น 4001-4011 ของการทดสอบ Dynamic fork ของเว็บไซต์ GitHub นั้นไม่ทำการทดสอบแบบดั้งเดิม เวอร์ชั่น 4013 ของ Dynamic fork ของเว็บไซต์ GitHub นั้นรวมถึงการทดสอบเบื้องต้น รหัสเพื่อทำการทดสอบแบบดั้งเดิมได้รับการพัฒนาขึ้นเป็นส่วนหนึ่งของการแก้ไขครั้งก่อนของคำตอบนี้

Perl 6 , 58 ไบต์

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

ลองออนไลน์!

10, 10 * * ...^ * > $_$_เป็นลำดับเรขาคณิตของหลายสิบดำเนินการจนกว่าจะมีใครก่อนองค์ประกอบที่เกินพารามิเตอร์การป้อนข้อมูล จากนั้นเราก็ตรวจสอบว่าสำหรับกำลังสิบแต่ละครั้งผลรวมของพารามิเตอร์อินพุตที่ถ่ายไว้ div และ mod ที่กำลังสำคัญ

Haskell, 114 110 ไบต์

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

ไม่พอใจกับคำอธิบาย:

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

ความจริง 88 ไบต์

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)

การทดสอบและผลลัพธ์

(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 ไบต์

{~cĊℕᵐ+}ᶠṗᵐ

ลองออนไลน์!

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

Perl 6 , 35 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

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

ซ้อนกัน 51 ไบต์

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

ลองออนไลน์!

นี่คือฟังก์ชั่น มันทำงานได้โดยการแปลงอาร์กิวเมนต์เป็นสตริง ( tostr), ทำซ้ำมันและได้รับความยาว ( :#'), ลบ 1 ( 1-) ทำให้ช่วงจาก 1 เป็นตัวเลขนั้น ( ~>) สแต็กมีลักษณะดังนี้สำหรับอินพุต40427:

('40427' (1 2 3 4))

เราดำเนินการ vectorized splitatทำให้อาร์เรย์ดังต่อไปนี้อยู่ด้านบนสุดของสแต็ก:

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

การโอนย้ายสิ่งนี้ด้วยtrเราจะได้รับ:

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

จากนั้นเราแมปฟังก์ชัน['+',' '## ~ prime] (withmap`) ฟังก์ชั่นนี้ทำ:

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

จากนั้นหลังจากที่แผนที่เรา 1concatenate นี่คือเนื่องจากallส่งคืนundefสำหรับรายการว่าง

JavaScript (ES6), 70 ไบต์

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)

ล้มเหลวในกรณีสุดท้ายในเบราว์เซอร์ของฉันเนื่องจากข้อผิดพลาด "เรียกซ้ำมากเกินไป" P(200023)ขณะที่การคำนวณ หวังว่านี่จะไม่เป็นโมฆะ

QBIC , 38 ไบต์

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

คำอธิบาย

_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 ไบต์)

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

สาธิตออนไลน์ , ชุดทดสอบออนไลน์

การผ่า

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 ไบต์

.AmP_svcz]dtUz

ชุดทดสอบ

บันทึกเป็นไบต์โดยใช้การเปลี่ยนแปลงล่าสุดของ Pyth

APL (NARS), ตัวอักษร 35, 70 ไบต์

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

ทดสอบ:

  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 

นี่จะเป็นการแปลใน APL จาก Axiom post algo ที่นี่ ...

{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 ไบต์

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;

พิมพ์1ถ้าอินพุตไม่เห็นแก่ตัวเอาต์พุตว่างถ้าไม่ ทำงานเป็นท่อที่มี-nRหรือลองออนไลน์

Perl 5 -p , 42 ไบต์

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

ลองออนไลน์!