Cho một số nguyên dương làm đầu vào xác định nếu đó là một số hào phóng.

Một số hào phóng là một số sao cho bất kỳ việc chèn một +dấu nào giữa hai chữ số bất kỳ trong cơ sở 10 đều dẫn đến một biểu thức của một số nguyên tố.

Ví dụ 40427 là hào hùng vì

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

Đầu ra

Bạn nên xuất hai giá trị riêng biệt, một khi đầu vào lớn và một khi đầu vào không.

Chấm điểm

Mục tiêu của cuộc thi này sẽ là làm cho kích thước của mã nguồn được viết để giải quyết nhiệm vụ này, được đưa ra bằng byte, càng nhỏ càng tốt.

Các trường hợp thử nghiệm

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

Mã

η¨¹.s¨R+pP

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm!

Giải trình

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

Tất cả các tối ưu hóa đã tắt và chỉ trên GCC 32-bit.

-1 byte nhờ @ceilingcat

+ một số byte cho 1trường hợp.

+ một số byte cho các chức năng tái sử dụng.

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

Lấy đầu vào là một số nguyên. Trả về 1 cho các trường hợp sai, 0 cho các trường hợp đúng.

Hãy thử trực tuyến!

Xem câu trả lời khác của tôi cho mã Mathicala (55 byte).

Võng mạc , 38 byte

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

Hãy thử trực tuyến!

In 1cho số hào hùng và 0cách khác.

Giải trình

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

Chúng tôi bắt đầu bằng cách khớp từng vị trí giữa hai chữ số (vị trí không có ranh giới từ) và chèn cả tiền tố và hậu tố của từ đó khớp với nhau, sử dụng _làm chữ số đơn. Vì vậy, thay vì chèn +s, chúng tôi trực tiếp chèn kết quả đơn nguyên của tổng ở đó.

S`\d

Bây giờ chúng tôi chia chuỗi xung quanh các chữ số, sao cho mỗi tổng sẽ đi trên một dòng riêng và chúng tôi loại bỏ các chữ số đó (cũng sẽ có một dòng dẫn và dấu trống rỗng, nhưng điều đó không quan trọng).

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

Đây là regex tiêu chuẩn để khớp với các số không nguyên tố trong unary. Sử dụng một Ggiai đoạn đại diện ở đây có nghĩa là chúng ta chỉ cần giữ tất cả các dòng có chứa các số nguyên tố dương (loại bỏ các dòng trống).

^$

Cuối cùng chúng tôi kiểm tra xem chuỗi có trống không. Nếu đầu vào là hào hùng, giai đoạn trước sẽ loại bỏ tất cả các dòng (vì chúng đều là số nguyên tố), và điều này mang lại cho chúng ta 1. Mặt khác, nếu bất kỳ dòng nào không phải là số nguyên tố, nó sẽ vẫn nằm trong chuỗi và regex không thành công, cho 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))

Điều này là chậm và chỉ có thể đối phó với các trường hợp thử nghiệm với sự ghi nhớ.

Hãy thử trực tuyến!

Phiên bản thay thế, 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))

Tăng tốc với chi phí của một byte.

Hãy thử trực tuyến!

Thạch , 12 byte

DJ⁵*⁸dṖS€ÆPẠ

Hãy thử trực tuyến!

Xác nhận tất cả các trường hợp thử nghiệm.

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 cảm ơn @PeterTaylor bằng cách sử dụng số học (thay vì String với .substring) và loại bỏ phương thức riêng biệt để kiểm tra xem số nguyên có phải là số nguyên tố hay không.
-6 byte sử dụng phương thức kiểm tra chính của @SaraJ , vì vậy hãy đảm bảo nâng cấp cô ấy!

Hãy thử nó ở đây.

Giải trình:

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

Bình thường , 14 byte

.AmP_ssMcQ]dtU

Hãy thử trực tuyến! Sẽ hiển thị Truenếu số lượng hào phóng, Falsenếu không. Lấy số dưới dạng một chuỗi.

Giải thích

.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

• Cảm ơn @Wheat Wizard cho 2 byte: được iẩn danh hoàn toàn vì nó chỉ được gọi một lần.
• Cảm ơn @Hyperneutrino cho 4 byte: cách thông minh hơn để lấy các số từ số chính thay vì cắt
• @Hyperneutrino đã lưu thêm 2 byte: x-1chỉ xđể kiểm tra rarnge.
• Đã sửa lỗi không thành công x=10, do đó thêm 7 Byte, nhờ @Dennis và @Wheat Wizard đã phát hiện ra: phiên bản trước đó của tôi đang xem xét 1 số nguyên 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`)))

Hãy thử trực tuyến!

Japt , 24 16 byte

Đây là sự hợp tác giữa @Shaggy, @ETHproduction và bản thân tôi.

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng một chuỗi.

Pip , 25 24 byte

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

Hãy thử trực tuyến!

Giải trình

alà đối số dòng lệnh đầu tiên. 1,#atạo một Phạm vi chứa các số 1thông qua len(a)-1. Về vấn đề này, chúng tôi ánh xạ một hàm lambda:

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

Tiếp theo, chúng tôi ánh xạ một hàm lambda khác 0N_%,_=1, đó là kiểm tra tính nguyên thủy. Tôi lấy nó từ câu trả lời này ; bạn có thể đọc lời giải thích ở đó. Cuối cùng, chúng tôi gấp danh sách trên logic AND ( $&). Kết quả là 1tất cả các khoản tiền đều là số nguyên tố, 0nếu bất kỳ ai trong số họ không có.

Ví dụ, với đầu vào của 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!},!

Hãy thử trực tuyến!

In số nguyên dương cho trung thực, không cho giả.

-1 nhờ một mánh khóe thông minh của Peter Taylor .
-3 nhờ một lời khuyên khác của Peter Taylor.

Japt , 23 byte

Đưa đầu vào dưới dạng một chuỗi.

Đăng nó; Tôi đã làm việc với một cú đấm ngắn hơn nhiều.

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

Kiểm tra nó

Toán học, 75 byte

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

Functionmà mong đợi a String. PrimeQ@ToExpression@StringInsert[#,"+",n]trả về việc chèn a +sau nchữ số thứ cho số nguyên tố. Table[...,{n,2,StringLength@#}]đưa ra danh sách các giá trị này dưới dạng nphạm vi từ2 đến độ dài của chuỗi. Sau đó chúng tôi lấy Andtừng yếu tố của danh sách đó. Thuận tiện, nếu StringLength@#<2, sau đó Table[...]là danh sách trống, màAnd@@{}==True

Toán học, 55 50 45 49 50 54 62 byte

Có vẻ như tôi nên đăng nó một cách riêng biệt.

+6 byte cho độ dài mã được phục hồi.

+5 byte nhờ ngenisis.

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

Lấy đầu vào là một số nguyên và trả về thường xuyên Truevà False. Ở giữa là unicode 0xF4A1, viết tắt của Function[,]. Độ dài mã được đo trên kích thước tệp (UTF-8 không có BOM), nhận xét nếu nó không chính xác.

PowerRange[x]trả về 1, 10, 100 ... không lớn hơn x, được giới thiệu trong Mathicala 10.

Tiếng Anh đơn giản 4.204 341 315 251 241 240 byte

(Re-) đã kết hợp kiểm tra tính nguyên thủy vào thư viện của Plain English, bằng cách di chuyển 3.863 byte vào thư viện của Plain English. Đã xóa 26 byte khoảng trắng. Đã lưu 64 byte bằng cách viết tắt các biến cục bộ. Đã lưu 10 byte bằng cách viết tắt giao diện. Theo đề xuất của RosLuP , đã lưu 1 byte bằng cách thay đổi cách khởi tạo và tăng 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.

Phiên bản mã hóa cuối cùng:

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.

Ghi chú: IDE tiếng Anh đơn giản có sẵn tại github.com/Folds/english . IDE chạy trên Windows. Nó biên dịch thành mã x86 32 bit.

Cái nĩa động của Plain English của Osmosian Order đã được thử nghiệm nguyên thủy trong phiên bản 4700, nhưng nó đã sử dụng một thuật toán rất kém hiệu quả (từ tháng 1 đến tháng 6 năm 2017). Các phiên bản 4001-4011 của thử nghiệm tính nguyên thủy của trang GitHub đã bỏ qua kiểm tra tính nguyên thủy. Phiên bản 4013 của ngã ba động của trang GitHub bao gồm thử nghiệm nguyên thủy. Mã để thực hiện kiểm tra tính nguyên thủy đã được phát triển như một phần của các phiên bản trước của câu trả lời này.

Perl 6 , 58 byte

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

Hãy thử trực tuyến!

10, 10 * * ...^ * > $_là chuỗi hình học của bội số của mười, được thực hiện cho đến một trước phần tử vượt quá tham số đầu vào $_. Sau đó, chúng tôi chỉ kiểm tra rằng với mỗi công suất mười, tổng của tham số đầu vào lấy div và mod công suất đó là số nguyên tố.

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

Ung dung với lời giải thích:

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

Tiên đề, 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)

kiểm tra và kết quả

(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Ċℕᵐ+}ᶠṗᵐ

Hãy thử trực tuyến!

{      }ᶠ      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}

Hãy thử trực tuyến!

Giải trình:

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

Xếp chồng lên nhau , 51 byte

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

Hãy thử trực tuyến!

Đây là một chức năng. Nó hoạt động bằng cách chuyển đổi đối số của nó thành một chuỗi ( tostr), sao chép nó và lấy độ dài của nó ( :#'), trừ đi 1 ( 1-), tạo một phạm vi từ 1 đến số đó ( ~>). Ngăn xếp trông giống như thế này, cho đầu vào 40427:

('40427' (1 2 3 4))

Chúng tôi thực hiện vector hóa splitat, dẫn đến mảng sau nằm ở đầu ngăn xếp:

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

Chuyển đổi điều này với tr, chúng tôi nhận được:

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

Sau đó, chúng tôi ánh xạ hàm ['+',' '## ~ Prime] (withmap`). Chức năng này không:

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

Sau đó, sau khi bản đồ, chúng tôi nối lại 1. Điều này là kể từ khi alltrả về undefcho một danh sách trống.

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)

Thất bại trong trường hợp cuối cùng trong trình duyệt của tôi do lỗi "quá nhiều đệ quy" trong khi tính toán P(200023). Hy vọng điều này không làm mất hiệu lực nó.

QBIC , 38 byte

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

Giải trình

_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!},!

Bản demo trực tuyến , trực tuyến bộ kiểm tra trực tuyến

Mổ xẻ

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

Bình thường, 15 14 byte

.AmP_svcz]dtUz

Bộ kiểm tra

Đã lưu một byte bằng thay đổi mới nhất của Pyth.

APL (NARS), ký tự 35, byte 70

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

kiểm tra:

  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 

Đây sẽ là bản dịch trong APL từ Axiom post algo tại đây ...

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

in 1nếu đầu vào hào phóng, đầu ra trống nếu không. Chạy như ống với -nRhoặc thử trực tuyến .

Perl 5 -p , 42 byte

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

Hãy thử trực tuyến!