Виклик:

Враховуючи число, візьміть найбільший простий строго менший за нього, відніміть його від цього числа, зробіть це ще раз із цим новим числом із найбільшим простим розміром менше, ніж його, і продовжуйте робити це, поки воно не стане менше 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(truthy).

Спробуйте в Інтернеті! (Перший рядок включає тестовий набір, відокремлений виведенням ліній.)

Пояснення

.+
$*

Перетворити вхід в одинаковий, перетворивши вхід Nу Nкопії 1.

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

Неодноразово знімайте найбільший прайм менше, ніж вхідний. Це ґрунтується на стандартному тесті первинності з регулярним виразом .

^1$

Перевірте, чи результат одиничний 1.

Піт, 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.

Математика, 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 !

Тестові шафи

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помилки.

Пітон, з симпатією, 60 байт

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

Мій попередній метод склав 83 байти без симпатії з використанням рекурсії, але я вважав, що truthy / falsey означає різницю та послідовність, але мені повідомили, що це неправильне тлумачення. Я, здається, не можу врятувати її через хвіст, але я залишу його тут, якщо хтось знає, як це зробити:

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

Віци, 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_кожен раз. Потім він видаляє всі _s. Якби я не забув breakу своєму коді, він міг би бути записаний так:

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

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

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

Я використав регекс з відповіді Мартіна Ендера .

Хаскелл, 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

Матлаб, 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

Thx @TuukkaX на ще 1 байт!

Флороїд , 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, це один довгий фрагмент коду. Найбільш багатослівна мова знову вражає!

Безголівки:

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