Вызов:

Для заданного числа возьмите наибольшее простое число строго меньше его, вычтите его из этого числа, сделайте это снова для этого нового числа с наибольшим простым числом, меньшим его, и продолжайте делать это до тех пор, пока оно не станет меньше 3. Если оно достигнет 1, ваше программа должна вывести истинное значение, иначе программа должна вывести значение фальси.

Примеры:

Все это должно дать истинное значение:

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.

Pyth, 18 15 14 байтов

Спасибо @Maltysen за -1 байт

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

JavaScript (ES6), 64 63 байта

Сохранено 1 байт благодаря @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))

Я написал это за 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 простое число; вернуть х .
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

Возвращает, 1если true, и вызывает исключение, если 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.

Mathematica, 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, но я пока не могу ее проверить :(

-2 байта, спасибо @JonathanAllan !

-1 байт, спасибо @Aaron !

Testcases

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ложь.

Python, с симптом, 60 байтов

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

Мой предыдущий метод составлял 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 байта.

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

Perl, 42 байта

Включает +1 для -p

Запустить с вводом на STDIN

reach1.pl:

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

Использует классическое регулярное выражение

.NET Regex, 38 байт

Просто чтобы показать, что это можно проверить в одном регулярном выражении.

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

Ввод предполагается в унарном виде.

объяснение

Он просто реализует требование к слову, многократно удаляя наибольшее простое число и проверяя, равен ли остаток 1.

• (?>(?<=(.*))..+(?<!^\1\2+(.+.)|$))+Группа, не занимающаяся отслеживанием обратной связи, следит за тем, чтобы найденное нами наибольшее простое число не было переопределено, и +просто повторяет процесс сопоставления наибольшего простого числа.

  • (?<=(.*))..+(?<!^\1\2+(.+.)|$): Сопоставьте наибольшее простое число меньше оставшегося числа

    • (?<=(.*)): Запишите, сколько мы вычли, чтобы установить «опорную» точку для утверждения.

    • ..+: Искать наибольшее число ...

    • (?<!^\1\2+(.+.)|$): ... который является простым и меньше, чем оставшееся число.
      • (?<!^\1\2+(.+.)): Обычная процедура первичного тестирования, с ^\1прикрепленным спереди, чтобы убедиться, что мы проверяем сумму, соответствующую..+
      • (?!<$): Утверждать меньше, чем оставшееся число

Perl 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_каждый раз. Затем он удаляет все _с. Если бы я не забыл breakв своем коде, это можно записать так:

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

Следующая часть многократно удаляет наибольшее простое число из входных данных, пока оно не станет равным 1или 11с 11заменой на 0.

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

Я использовал регулярное выражение из ответа Мартина Эндера .

Haskell, 79 байтов

Не очень коротко, но бессмысленно :)

(<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)..2помощью оператора Where-Object( ?), затем первого [0]из результатов (поскольку диапазон уменьшается, это приводит к выбору наибольшего). После завершения цикла, $nбудет или будет, 1или 2, по определению, поэтому мы предварительно уменьшаем $n(превращаем его в либо 0или 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 , но необходимо, чтобы переменная была в рабочей области.

Python 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

Спасибо @TuukkaX за -1 байт!

Floroid , 45 30 29 байт

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

Clojure, 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, это один длинный кусок кода. Самый многословный язык поражает снова!

Ungolfed:

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