입력으로 양의 정수가 주어지면 대수인지 판별하십시오.

대수는 +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 비트에서만 사용되었습니다.

@ceilingcat 덕분에 -1 바이트

경우에 + 바이트 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+$

이것은 단항의 비 프라임 숫자와 일치하는 표준 정규식입니다. G여기 에서 rep 단계를 사용 한다는 것은 우리가 단순히 비 프라임을 포함하는 모든 라인을 유지한다는 것을 의미합니다 (빈 라인은 버림).

^$

마지막으로 문자열이 비어 있는지 확인합니다. 입력이 장엄한 경우 이전 단계는 모든 줄을 버렸을 것입니다 (모두 프라임 이었기 때문에) 1. 그렇지 않으면 줄이 소수가 아닌 경우 문자열에 남아 있고 정규 표현식이 실패하여을 제공 0합니다.

파이썬 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))

1 바이트의 비용으로 속도가 빨라졌습니다.

온라인으로 사용해보십시오!

젤리 , 12 바이트

DJ⁵*⁸dṖS€ÆPẠ

온라인으로 사용해보십시오!

모든 테스트 사례를 확인하십시오.

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

@PeterTaylor 덕분에 (with with with String 대신) 산술을 사용 .substring하고 정수가 소수인지 확인하기 위해 별도의 메소드를 제거했습니다. @SaraJ 의 프라임 체크 방법을
사용하여 -6 바이트 이므로, 그녀 를 찬성 해야합니다!

여기에서 시도하십시오.

설명:

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

파이썬 (2) , 104 (102) 98 96 103 바이트

• 2 바이트에 대한 @Wheat Wizard 덕분에 i한 번만 호출되므로 완전히 익명으로 만들었 습니다.
• 4 바이트에 대한 @Hyperneutrino 덕분에 슬라이싱 대신 기본 숫자에서 숫자를 얻는 더 똑똑한 방법
• @Hyperneutrino 다른 2 바이트를 저장 : x-1단지에 x주요 검사 rarnge을 위해.
• x=10@Dennis 및 @Wheat Wizard 덕분에 7 바이트를 추가하여 사례를 수정 했습니다. 이전 버전은 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

온라인으로 사용해보십시오!

입력을 문자열로받습니다.

핍 , 25 24 바이트

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

온라인으로 사용해보십시오!

설명

a첫 번째 명령 줄 인수입니다. 통해 1,#a숫자 1를 포함하는 범위를 생성합니다 len(a)-1. 여기에 람다 함수를 매핑합니다 :

$+(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!},!

온라인으로 사용해보십시오!

진리의 경우 양의 정수를, 거짓의 경우 0을 인쇄합니다.

Peter Taylor 의 영리한 속임수 덕분에 -1 .
Peter Taylor의 또 다른 팁 덕분에 -3.

Japt , 23 바이트

입력을 문자열로받습니다.

댕 내가 작업했던 훨씬 더 짧은 대안을 펀치 에 맞았습니다 .

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

그것을 테스트

Mathematica, 75 바이트

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

Function기대합니다 String. 숫자 뒤에 숫자를 PrimeQ@ToExpression@StringInsert[#,"+",n]삽입 하면 소수 가되는지 여부를 반환합니다 . 이러한 값 목록 제공 범위 문자열의 길이를. 그런 다음 해당 목록의 각 요소 를 가져 옵니다. 편리 경우 , 다음 의 빈리스트이며,+nTable[...,{n,2,StringLength@#}]n2AndStringLength@#<2Table[...]And@@{}==True

매스 매 티카, 55 50 45 49 50 54 62 바이트

별도로 게시해야합니다.

코드 길이가 재 측정 된 경우 +6 바이트

ngenisis 덕분에 +5 바이트

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

입력을 정수로 받아서 일반 True및을 반환 False합니다. 에서-사이 0xF4A1 유니 코드의 약자입니다 Function[,]. 코드 길이는 파일 크기 (BOM없는 UTF-8)에서 측정되며, 올바르지 않은 경우 주석 처리됩니다.

PowerRange[x]xMathematica 10에 도입 된 1보다 크지 않은 1, 10, 100 ...을 반환합니다 .

일반 영어 4204 341 315 251 241 240 바이트

3,863 바이트를 Plain English의 라이브러리로 이동하여 Plain English의 라이브러리에 원시 테스트를 다시 통합했습니다. 26 바이트의 공백을 삭제했습니다. 지역 변수를 줄여 64 바이트를 절약했습니다. 인터페이스를 줄여 10 바이트를 절약했습니다. 당 RosLuP 의 제안, m 초기화 및 증분 방식 변경에 의해 1 바이트를 저장.

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.

참고 : Plain English IDE는 github.com/Folds/english 에서 사용할 수 있습니다 . IDE는 Windows에서 실행됩니다. 32 비트 x86 코드로 컴파일됩니다.

Osmosian Order 의 동적 영어 포크는 버전 4700에서 이미 우선 순위 테스트를 받았지만 2017 년 1 월부터 6 월까지 매우 비효율적 인 알고리즘을 사용했습니다. GitHub 사이트의 동적 포크 버전 4001-4011은 기본 테스트를 생략했습니다. GitHub 사이트의 동적 포크 버전 4013에는 우선 순위 테스트가 포함되어 있습니다. 원시성 테스트를 수행하는 코드는이 답변의 이전 개정의 일부로 개발되었습니다.

펄 6 , 58 바이트

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

온라인으로 사용해보십시오!

10, 10 * * ...^ * > $_입력 매개 변수를 초과하는 요소 앞에 1이 될 때까지 10의 배수로 구성된 기하학적 시퀀스입니다 $_. 그런 다음 각 10의 거듭 제곱, 입력 매개 변수의 합 div 및 mod가 거듭 제곱임을 확인합니다.

하스켈, 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.

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

그런 다음지도 다음에 연결 1합니다. 이것은 빈 목록을 all반환 undef하기 때문 입니다.

자바 스크립트 (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 

이것은 Axiom post algo here의 APL 번역입니다 ...

{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하거나 온라인으로 사용해보십시오 .

펄 5 -p , 42 바이트

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

온라인으로 사용해보십시오!