도전:

숫자가 주어지면 가장 큰 소수를 그보다 엄격하게 줄이고이 숫자에서 빼고 가장 큰 소수를 가진 새로운 숫자로 다시이 작업을 수행하고 3보다 작을 때까지 계속하십시오. 프로그램은 정확한 값을 출력해야하며, 그렇지 않으면 프로그램은 잘못된 값을 출력해야합니다.

예 :

이 모든 것이 진실 된 가치를 제공해야합니다.

3
4
6
8
10
11
12
14
16
17
18
20
22
23
24
26
27
29
30
32
34
35
37
38
40
41
42
44
46
47
48
50

이들 모두는 잘못된 값을 제공해야합니다.

5
7
9
13
15
19
21
25
28
31
33
36
39
43
45
49

규칙 :

• 프로그램이나 함수를 작성할 수 있습니다.
• 입력이 2보다 크다고 가정 할 수 있습니다.
• 표준 허점 적용
• 이것은 코드 골프 이므로 최단 답변이 이깁니다!

젤리 , 9 8 바이트

’ÆRṪạµ¡Ḃ

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

’ÆRṪạµ¡Ḃ  Main link. Argument: n

     µ    Combine all atoms to the left into a chain.
’           Decrement; yield n - 1.
 ÆR         Prime range; yield all primes in [2, ..., n -1].
   Ṫ        Tail; yield p, the last prime in the range.
            If the range is empty, this yields p = 0.
    ạ       Compute the absolute difference of p and n.
      ¡   Call the chain to the left n times.
          This suffices since each iteration decreases n, until one of the fixed
          points (1 or 2) is reached.
       Ḃ  Bit; return the parity of the fixed point.

망막 , 31 바이트

.+
$*
+`1(?!(11+)\1+$)11+
1
^1$

0(거짓) 또는 1(거친) 인쇄합니다 .

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

설명

.+
$*

입력 N을의 N사본으로 바꾸어 입력을 단항으로 변환합니다 1.

+`1(?!(11+)\1+$)11+
1

입력 값보다 작은 소수를 반복해서 제거하십시오. 이것은 정규식 표준 표준 테스트를 기반으로 합니다 .

^1$

결과가 단일인지 확인하십시오 1.

피스, 18 15 14 바이트

-1 바이트에 대한 @Maltysen 덕분에

#=-QefP_TUQ)q1

STDIN에 입력하여 인쇄 True하거나 False적절한 프로그램.

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

작동 원리

#=-QefP_TUQ)q1  Program. Input: Q
#          )    Loop until error statement (which occurs when Q<3):
         UQ      Yield [0, 1, 2, 3, ..., Q-1]
     fP_T        Filter that by primality
    e            Yield the last element of that
 =-Q             Q = Q - that
            q1  Q is 1 (implicit variable fill)
                Implicitly print

축소, 18 바이트의 이전 버전

qu-G*<HGH_fP_TSQQ1

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

작동 원리

qu-G*<HGH_fP_TSQQ1  Program. Input: Q
              SQ    Yield [1, 2, 3, ..., Q]
          fP_T      Filter that by primality
         _          Reverse it
 u                  Reduce it:
                Q    with base case Q and
                     function G, H -> 
     <HG              H<G
    *   H             *H (yields H if H<G, else 0)
  -G                  Subtract that from G
q                1  The result of that is 1
                    Implicitly print

자바 스크립트 (ES6), 64 63 바이트

@Neil 덕분에 1 바이트 절약

g=(x,n=x-1)=>n<2?x:x%n?g(x,n-1):g(x-1)
f=x=>x<3?x%2:f(x-g(x-1))

나는 이것을 2 분 안에 썼다. 그리고 그것은 처음으로 완벽하게 작동했다. 불가피한 버그 승리를 발견 한 최초의 사용자 ....

사용해보십시오

g=(x,n=x-1)=>n<2?x:x%n?g(x,n-1):g(x-1)
f=x=>x<3?x%2:f(x-g(x-1))

<input type="number" value=3 min=3 onchange="A.innerHTML=f(this.value)"><br>
<p id=A>1</p>

작동 원리

먼저 g (x) 를 첫 번째 소수 p <= x 를 찾는 함수로 정의합니다. 합니다. 이것은 다음 프로세스를 사용하여 수행됩니다.

1. 로 시작 n = x-1로 .
2. 만약 N <2 , X는 소수이고; 반환x를 합니다.
3. 경우 x는 로 나누어 N , 감소 X 및 1 단계로 이동합니다.
4. 그렇지 않으면 n 을 줄이고 2 단계로 이동하십시오.

이 과제 f (x)에 대한 해결책 은 이제 매우 간단합니다.

1. x <3 인 경우 x = 1을 반환하십시오 .
2. 그렇지 않으면 g (x-1)을 빼고 다시 시도하십시오.

파이크, 15 11 바이트

WDU#_P)e-Dt

여기 사용해보십시오!

            - stack = input
W           - while continue:
  U#_P)     -     filter(is_prime, range(stack))
       e    -    ^[-1]
 D      -   -   stack-^
         Dt -  continue = ^ != 1

1true 인 경우 반환 하고 false 인 경우 예외를 발생시킵니다.

줄리아, 32 바이트

언어 중에서 가장 짧은 해결책은 아니지만 사람이 읽을 수있는 것 중 가장 짧은 해결책 일 수 있습니다 ...

!n=n>2?!(n-primes(n-1)[end]):n<2

또는 좀 더 명확한 용어로

function !(n)
  if n>2
    m=primes(n-1)[end]   # Gets largest prime less than n
    return !(n-m)        # Recurses
  else
    return n<2           # Gives true if n is 1 and false if n is 2
  end
end

예를 들어으로 호출됩니다 !37.

수학, 32 바이트

2>(#//.x_/;x>2:>x+NextPrime@-x)&

이것은 이름없는 함수이며 정수를 취하고 부울을 반환합니다.

설명

여기에는 많은 구문과 재미있는 읽기 순서가 있습니다.

   #                               This is simply the argument of the function.
    //.                            This is the 'ReplaceRepeated' operator, which applies
                                   a substitution until the its left-hand argument stops
                                   changing.
       x_/;x>2                     The substitution pattern. Matches any expression x as
                                   long as that expression is greater than 2.
              :>                   Replace that with...
                  NextPrime@-x     Mathematica has a NextPrime built-in but no
                                   PreviousPrime built-in. Conveniently, NextPrime
                                   works with negative inputs and then gives you the 
                                   next "negative prime" which is basically a
                                   PreviousPrime function (just with an added minus sign).
                x+                 This gets added to x, which subtracts the previous
                                   prime from it.
2>(                           )    Finally, we check whether the result is less than 2.

Python3, 102 92 90 89 88 바이트

f=lambda n:n<2if n<3else f(n-[x for x in range(2,n)if all(x%y for y in range(2,x))][-1])

골프 제안을 환영합니다! gmpy함수 가 포함되어 next_prime있지만 아직 테스트 할 수는 없습니다. (

@JonathanAllan 덕분에 -2 바이트 !

@Aaron 덕분에 -1 바이트 !

테스트 케이스

f=lambda n:n<2if n<3else f(n-[x for x in range(2,n)if all(x%y for y in range(2,x))][-1])

s="3 4 6 8 10 11 12 14 16 17 18 20 22"
h="5 7 9 13 15 19 21 25 28 31 33 36 39"

for j in s.split(" "):print(f(int(j)))
for j in h.split(" "):print(f(int(j)))

출력은 13 개의 참값과 13 개의 거짓 값입니다. s진실한 사건과 거짓을 포함합니다 h.

Sympy, 60 바이트의 Python

import sympy
f=lambda n:n>2and f(n-sympy.prevprime(n))or n<2

내 이전 방법은 재귀를 사용하여 sympy가없는 83 바이트 였지만 구별 할 수 있고 일관성이 있음을 진실 / 거짓으로 생각했지만 잘못된 해석이라고 들었습니다. 꼬리 때문에 그것을 구할 수는 없지만 누군가 그렇게하는 방법을 알고 있다면 여기에 남겨 두겠습니다.

f=lambda n,p=0:n>2and(any(p%x==0for x in range(2,p))and f(n,p-1)or f(n-p,n+~p))or n

Vitsy, 28 26 바이트

이것은 분명히 단축 될 수 있습니다.

<]xN0)l1)-1[)/3D-];(pD-1[D

‮

<                    Traverse the code in this direction, rotating on the line.
                     For the sake of reading the code easier, I'm reversing the
                     code on this line. This will be the order executed.

 D[1-Dp(;]-D3/)[1-)1l)0Nx]
 D                         Duplicate the top member of the stack.
  [      ]                 Do the stuff in brackets until break is called.
   1-                      Subtract 1 from the top item of the stack.
     D                     Duplicate the top member of the stack.
      p(                   If the top member is a prime...
        ;                  break;
          -                Pop a, b, push a - b.
           D3/)[         ] If this value is less than 3, do the bracketed code.
                1-         Subtract the top item of the stack by 1.
                  )        If the top item is zero...
                   1       Push 1.
                    l)     If the length of the stack is zero...
                      0    Push 0.
                       N   Output the top member of the stack.
                        x  System.exit(0);

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

MATL , 13 바이트

`tqZq0)-t2>}o

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 한 번에 확인하십시오 .

설명

`        % Do...while
  t      %   Duplicate. Takes input implicitly in the first iteration
  qZq    %   All primes less than that
  0)     %   Get last one
  -      %   Subtract (this result will be used in the next iteration, if any)
  t      %   Duplicate
  2>     %   Does it exceed 2? If so: next iteration. Else: execute the "finally" 
         %   block and exit do...while loop
}        % Finally
  o      %   Parity. Transforms 2 into 0 and 1 into 1
         % End do...while implicitly
         % Display implicitly

CJam , 21 16 바이트

4 바이트를 절약 해 준 Dennis에게 감사합니다.

ri{_1|{mp},W=-}h

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

설명

ri       e# Read input and convert to integer N.
{        e# Run this block as long as N is positive (or until the program aborts
         e# with an error)...
  _1|    e#   Duplicate and OR 1. This rounds up to an odd number. For N > 2, this
         e#   will never affect the greatest prime less than N.
  {mp},  e#   Get all primes from 0 to (N|1)-1.
         e#   For N > 2, this will contain all primes less than N.
         e#   For N = 2, this will contain only 2.
         e#   For N = 1, this will be empty.
  W=     e#   Select the last element (largest prime up to (N|1)-1).
         e#   For N = 1, this will result in an error and terminate the program, which
         e#   still prints the stack contents though (which are 1, the desired output).
  -      e#   Subtract from N. Note that this gives us 0 for N = 2, which terminates the 
         e#   loop.
}h

펄, 42 바이트

에 +1 포함 -p

STDIN의 입력으로 실행

reach1.pl:

#!/usr/bin/perl -p
$_=1x$_;$_=$`while/\B(?!(11+)\1+$|$)|11$/

고전적인 원시 정규식을 사용합니다.

.NET 정규식, 38 바이트

단일 정규식에서 확인할 수 있음을 보여주기 위해.

^(?>(?<=(.*))..+(?<!^\1\2+(.+.)|$))+.$

입력은 단항으로 가정합니다.

설명

그것은 단순히 단어에 대한 요구 사항을 구현하고 가장 큰 소수를 반복적으로 제거하고 나머지가 1인지 여부를 확인합니다.

• (?>(?<=(.*))..+(?<!^\1\2+(.+.)|$))+: 역 추적이 아닌 그룹은 찾은 가장 큰 소수가 무시되지 않도록하고 +단순히 가장 큰 소수를 일치시키는 프로세스를 반복합니다.

  • (?<=(.*))..+(?<!^\1\2+(.+.)|$): 남은 수보다 적은 가장 큰 소수와 일치

    • (?<=(.*)): 어설 션의 "앵커"포인트를 설정하기 위해 뺀 값을 기록하십시오.

    • ..+: 가장 큰 숫자를 찾으십시오 ...

    • (?<!^\1\2+(.+.)|$): ... 소수이며 나머지 수보다 작습니다.
      • (?<!^\1\2+(.+.)): 일반적인 프라임 테스트 루틴으로, ^\1일치하는 양을 확인하기 위해 앞에 고정됩니다...+
      • (?!<$): 나머지 수보다 적은 어설 션

펄 6 ,  54 53 52  51 바이트

{($_,{$_-($_-1...2).first: *.is-prime}...3>*)[*-1]==1}
{($_,{$_-($_-1...2).first: *.is-prime}...3>*).any==1}
{any($_,{$_-($_-1...2).first: *.is-prime}...3>*)==1}

{any($_,{$_-(^$_).grep(*.is-prime)[*-1]}...3>*)==1}

설명:

# bare block lambda with implicit parameter ｢$_｣
# used to generate all of the rest of the elements of the sequence
{
  # create an any Junction of the following list
  any(
    $_, # initialize sequence with the inner block's argument

    # bare block lambda with implicit parameter ｢$_｣
    {
      # take this inner block's argument and subtract
      $_ -

      ( ^$_ )            # Range up-to and excluding ｢$_｣
      .grep(*.is-prime)\ # find the primes
      [ * - 1 ]          # return the last value
    }

    ...   # keep doing that until

    3 > * # the result is less than 3

  # test that Junction against ｢1｣
  # ( returns an ｢any｣ Junction like ｢any(False, False, True)｣ )
  ) == 1
}

예:

# show what is returned and if it is truthy
sub show ($_) {
  # ｢.&{…}｣ uses the block as a method and implicitly against ｢$_｣
  my $value = .&{any($_,{$_-(^$_).grep(*.is-prime)[*-1]}...3>*)==1}
  say join "\t", $_, ?$value, $value.gist;
}

show 3;  # 3    True    any(False, True)
show 4;  # 4    True    any(False, True)
show 5;  # 5    False   any(False, False)
show 10; # 10   True    any(False, False, True)
show 28; # 28   False   any(False, False, False)
show 49; # 49   False   any(False, False)
show 50; # 50   True    any(False, False, True)

불규칙 , 63 바이트

p~?1_$-1p:;
n=i(0)?1_$-1p:;
_~
N=n
1(?!(11+)\1+$)11+~1
^11$~0
N

나는 이틀 전에이 언어를 만들었고 기본 구내에는 내장 루프가 없으며 유일한 기능은 기본 산술 및 의사 결정이며, 프로그램 평가는 정규식을 기반으로합니다.

설명

p~?1_$-1p:;
n=i(0)?1_$-1p:;
_~
N=n

이 부분은 입력을 단항으로 변환합니다. 1_매번 앞에 0이 될 때까지 입력에서 1을 반복적으로 뺍니다 . 그런 다음 모든 _s 를 제거합니다 . 내가 잊지 않았다면break내 코드에서를 다음과 같이 작성할 수 있습니다.

p~?1_$-1p:;
_~
n=i(0)?1_$-1p:;

이 동일해질 때까지 그 다음 부분을 반복해서 입력으로부터 가장 큰 소수를 제거 1또는 11으로 11대체되고0 .

1(?!(11+)\1+$)11+~1
^11$~0
N

Martin Ender의 답변 에서 정규식을 사용했습니다 .

하스켈, 79 바이트

정말 짧지는 않지만 pointfree :)

(<2).until(<3)(until(flip(`until`(+1))2.(.)(<1).mod>>=(==))pred.pred>>=flip(-))

PowerShell v2 +, 81 바이트

param($n)while($n-gt2){$n-=(($n-1)..2|?{'1'*$_-match'^(?!(..+)\1+$)..'})[0]}!--$n

입력을 $n받습니다. 들어갑니다 while너무 오래로 루프를 $n여전히 3이상. 각 반복은에서 숫자를 뺍니다 $n. 숫자는 ( ) 연산자 를 통해 범위에 대해 적용된 정규식 우선 순위 테스트 의 결과이며, 첫 번째 결과 (범위가 감소하기 때문에 가장 큰 결과가 선택됨). 루프 체결 후 가 될 것입니다 또는 우리가, 정의에 의해, 선행 감소 (하나에 돌려($n-1)..2Where-Object?[0]$n12$n0 또는 1)와 부울 아니라 받아 !이들. 그것은 파이프 라인에 남아 있으며 출력은 암시 적입니다.

예

PS C:\Tools\Scripts\golfing> 3..20|%{"$_ --> "+(.\can-the-number-reach-one.ps1 $_)}
3 --> True
4 --> True
5 --> False
6 --> True
7 --> False
8 --> True
9 --> False
10 --> True
11 --> True
12 --> True
13 --> False
14 --> True
15 --> False
16 --> True
17 --> True
18 --> True
19 --> False
20 --> True

Matlab, 51 바이트

v=@(x)x-max(primes(x-1));while(x>=3)x=v(x);end;x==1

이것은으로 JS6 솔루션과 매우 유사 ETHProductions 하지만 작업 공간에있을 변수를 필요로한다.

파이썬 2.7 : 88 87 바이트

r=lambda n:n>2and r(n-[a for a in range(2,n)if all(a%b for b in range(2,a))][-1])or n<2

-1 바이트 이상 @TuukkaX Thx!

플로 로이드 , 45 30 29 바이트

f=Bb:b<2Fb<3Gf(b-en(b-1)[-1])

클로저, 125 바이트

#(loop[x %](if(> x 2)(recur(- x(loop[y(dec x)](if(some zero?(vec(for[z(range 2 y)](mod y z))))(recur(dec y))y))))(quot 1 x)))

Yikes, 그것은 하나의 긴 코드 조각입니다. 가장 장황한 언어가 다시 파업합니다!

언 골프 드 :

(defn subprime [n]
  (loop [x n]
    (if (> x 2)
      (recur
        (- x
          (loop [y (dec x)]
            (if (some zero? (vec (for [z (range 2 y)] (mod y z))))
              (recur (dec y)) y))))
      (quot 1 x))))