Thử thách:

Cho một số, lấy số nguyên tố lớn nhất ít hơn số đó, trừ nó khỏi số này, làm lại số này với số nguyên tố lớn nhất ít hơn số đó và tiếp tục làm số này cho đến khi nó nhỏ hơn 3. Nếu nó đạt 1, số của bạn chương trình nên xuất ra một giá trị trung thực, nếu không, chương trình sẽ xuất ra một giá trị falsey.

Ví dụ:

Tất cả những điều này sẽ cho một giá trị trung thực:

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

Tất cả những điều này sẽ cho giá trị falsey:

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

Quy tắc:

• Bạn có thể viết một chương trình hoặc chức năng.
• Bạn có thể giả sử rằng đầu vào lớn hơn 2.
• Áp dụng sơ hở tiêu chuẩn
• Đây là môn đánh gôn nên câu trả lời ngắn nhất sẽ thắng!

Thạch , 9 8 byte

’ÆRṪạµ¡Ḃ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

’Æ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.

Võng mạc , 31 byte

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

In 0(giả) hoặc 1(trung thực).

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Giải trình

.+
$*

Chuyển đổi đầu vào thành unary bằng cách chuyển đầu Nvào thành Nbản sao của 1.

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

Liên tục loại bỏ số nguyên tố lớn nhất ít hơn đầu vào. Điều này dựa trên các thử nghiệm nguyên thủy tiêu chuẩn với regex .

^1$

Kiểm tra xem kết quả là một lần duy nhất 1.

Pyth, 18 15 14 byte

Cảm ơn @Maltysen cho -1 byte

#=-QefP_TUQ)q1

Một chương trình lấy đầu vào trên STDIN và in Truehoặc Falsekhi thích hợp.

Dùng thử trực tuyến

Làm thế nào nó hoạt động

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

Phiên bản cũ giảm, 18 byte

qu-G*<HGH_fP_TSQQ1

Dùng thử trực tuyến

Làm thế nào nó hoạt động

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

JavaScript (ES6), 64 63 byte

Đã lưu 1 byte nhờ @Neil

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

Tôi đã viết cái này trong 2 phút ... và nó đã hoạt động hoàn hảo ngay lần đầu tiên. Người dùng đầu tiên tìm thấy lỗi không thể tránh khỏi sẽ thắng ....

Dùng thử

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>

Làm thế nào nó hoạt động

Đầu tiên chúng ta định nghĩa g (x) là hàm tìm số nguyên tố đầu tiên p <= x . Điều này được thực hiện bằng cách sử dụng quy trình sau đây:

1. Bắt đầu với n = x-1 .
2. Nếu n <2 , x là số nguyên tố; trả lại x .
3. Nếu x chia hết cho n , giảm x và chuyển sang bước 1.
4. Nếu không, giảm n và đi đến bước 2.

Giải pháp cho thách thức này, f (x) , hiện khá đơn giản:

1. Nếu x <3 , trả về x = 1 .
2. Nếu không, hãy trừ g (x - 1) và thử lại.

Pyke, 15 11 byte

WDU#_P)e-Dt

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

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

Trả về 1nếu đúng và đưa ra một ngoại lệ nếu sai

Julia, 32 byte

Mặc dù nó sẽ không phải là giải pháp ngắn nhất trong số các ngôn ngữ, đây có thể là ngôn ngữ ngắn nhất trong số những ngôn ngữ mà con người có thể đọc được ...

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

Hoặc, để đặt nó trong điều khoản rõ ràng hơn một chút

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

Được gọi với, ví dụ , !37.

Toán học, 32 byte

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

Đây là một hàm không tên, lấy một số nguyên và trả về một boolean.

Giải trình

Có rất nhiều cú pháp và thứ tự đọc vui nhộn ở đây, vì vậy ...

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

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

Gợi ý chơi golf chào mừng! Tôi thấy gmpycó chứa một hàm next_prime, nhưng tôi chưa thể kiểm tra nó :(

-2 byte, cảm ơn @Jonathan ALLan !

-1 byte, nhờ @Aaron !

Tủ thử

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

Đầu ra là 13 giá trị trung thực và 13 giá trị falsey. schứa các trường hợp trung thực và hsai.

Python, với sympy, 60 byte

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

Phương pháp trước đây của tôi là 83 byte mà không cần sử dụng đệ quy, nhưng tôi lấy sự thật / falsey có nghĩa là có thể phân biệt và nhất quán, nhưng tôi đã được thông báo rằng đó là một cách giải thích không chính xác. Tôi dường như không thể cứu vãn nó do cái đuôi, nhưng tôi sẽ để nó ở đây trong trường hợp ai đó biết cách làm như vậy:

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 byte

Điều này chắc chắn có thể được rút ngắn.

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

Là một tài tài, hay nói, qua, qua, qua một khác, qua giữ, qua, qua một khác, qua, qua, qua, khi khác mới, khác mới, khi khác mới đăng, mới, mới đăng, mới đăng, mới đăng, mới đăng, mới đăng, mới đăng, mới đăng, mới đăng cam cam

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

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

MATL , 13 byte

`tqZq0)-t2>}o

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc .

Giải trình

`        % 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 byte

Cảm ơn Dennis vì đã tiết kiệm 4 byte.

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

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

Giải trình

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

Perl, 42 byte

Bao gồm +1 cho -p

Chạy với đầu vào trên STDIN

reach1.pl:

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

Sử dụng regex nguyên thủy cổ điển

.NET Regex, 38 byte

Chỉ để cho thấy rằng nó có thể được kiểm tra trong một regex duy nhất.

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

Đầu vào được giả định là đơn nhất.

Giải trình

Nó chỉ đơn giản là thực hiện các yêu cầu cho từ, liên tục loại bỏ số nguyên tố lớn nhất và kiểm tra xem phần còn lại có phải là 1 không.

• (?>(?<=(.*))..+(?<!^\1\2+(.+.)|$))+: Nhóm không quay lại đảm bảo số nguyên tố lớn nhất mà chúng tôi tìm thấy không bị quá tải và +chỉ cần lặp lại quy trình khớp với số nguyên tố lớn nhất.

  • (?<=(.*))..+(?<!^\1\2+(.+.)|$): Khớp số nguyên tố lớn nhất nhỏ hơn số còn lại

    • (?<=(.*)): Ghi lại số tiền chúng tôi đã trừ để thiết lập điểm "neo" để xác nhận.

    • ..+: Tìm kiếm số lượng lớn nhất ...

    • (?<!^\1\2+(.+.)|$): ... là số nguyên tố và ít hơn số còn lại.
      • (?<!^\1\2+(.+.)): Thói quen kiểm tra chính thông thường, được xử lý ^\1ở phía trước để đảm bảo chúng tôi đang kiểm tra số tiền khớp với..+
      • (?!<$): Khẳng định ít hơn số còn lại

Perl 6 ,  54 53 52  51 byte

{($_,{$_-($_-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}

Giải trình:

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

Thí dụ:

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

Không đều , 63 byte

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

Tôi đã tạo ra ngôn ngữ này hai ngày trước và tiền đề cơ bản là không có các vòng lặp tích hợp, các tính năng duy nhất là số học cơ bản và ra quyết định, và đánh giá chương trình dựa trên các biểu thức thông thường.

Giải trình

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

Phần này chuyển đổi đầu vào thành đơn nguyên. Nó liên tục trừ 1 từ đầu vào cho đến khi bằng 0, trả trước 1_mỗi lần. Sau đó nó loại bỏ tất cả các _s. Nếu tôi đã quên một breakmã trong mã của mình thì nó có thể được viết như vậy:

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

Phần tiếp theo liên tục loại bỏ số nguyên tố lớn nhất khỏi đầu vào cho đến khi nó bằng 1hoặc 11, 11được thay thế bằng 0.

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

Tôi đã sử dụng regex từ câu trả lời của Martin Ender .

Haskell, 79 byte

Không thực sự ngắn nhưng không có điểm :)

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

PowerShell v2 +, 81 byte

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

Đưa đầu vào $n. Nhập một whilevòng lặp miễn $nlà vẫn còn 3hoặc lớn hơn. Mỗi lần lặp, trừ một số từ $n. Số này là kết quả của phép thử nguyên hàm regex được áp dụng đối với một phạm vi ($n-1)..2thông qua toán tử Where-Object( ?), sau đó là lần đầu tiên[0] là kết quả (vì phạm vi đang giảm, điều này dẫn đến kết quả lớn nhất được chọn). Sau khi kết thúc vòng lặp, $nhoặc là sẽ 1hay 2, theo định nghĩa, vì vậy chúng tôi-sụt lần trước $n(biến nó thành một trong hai 0hoặc 1), và lấy Boolean-không !biết. Đó là còn lại trên đường ống và đầu ra là ẩn.

Ví dụ

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 byte

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

Đây là RẤT tương tự như giải pháp JS6 của ETH sản phẩm , nhưng cần biến trong không gian làm việc.

Python 2.7: 88 87 byte

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

Thx @TuukkaX cho -1 byte hơn!

Floroid , 45 30 29 byte

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

Clojure, 125 byte

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

Rất tiếc, đó là một đoạn mã dài. Các ngôn ngữ dài dòng nhất đình công một lần nữa!

Ung dung:

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