Одно из моих любимых определений простых чисел выглядит следующим образом:

2 - наименьшее простое число.
Числа больше 2 являются простыми, если они не делятся на меньшее простое число.

Однако это определение кажется произвольным, почему 2? Почему не какой-то другой номер? Что ж, давайте попробуем некоторые другие числа определим n-простое, что

n наименьшее n-простое число.
Числа, большие n, являются n-простыми, если они не делятся на меньшее n-простое число.

задача

Задача здесь состоит в том, чтобы написать программу, которая принимает два входа: положительное целое число n и положительное целое число a . Это будет решить , если является п -премьер. Ваша программа должна вывести два разных значения, одно для «да, это n-простое» и одно для «нет, это не n-простое».

Это вопрос кода игры в гольф, поэтому ответы будут оцениваться в байтах, причем меньше байтов будет лучше.

тесты

Вот списки первых 31 простых чисел от n = 2 до n = 12 (1 - единственное 1-простое число)

n=2: [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
n=3: [3,4,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
n=4: [4,5,6,7,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113]
n=5: [5,6,7,8,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113]
n=6: [6,7,8,9,10,11,13,15,17,19,23,25,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107]
n=7: [7,8,9,10,11,12,13,15,17,19,23,25,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107]
n=8: [8,9,10,11,12,13,14,15,17,19,21,23,25,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89,97]
n=9: [9,10,11,12,13,14,15,16,17,19,21,23,25,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89,97]
n=10: [10,11,12,13,14,15,16,17,18,19,21,23,25,27,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89]
n=11: [11,12,13,14,15,16,17,18,19,20,21,23,25,27,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89]
n=12: [12,13,14,15,16,17,18,19,20,21,22,23,25,27,29,31,33,35,37,41,43,47,49,53,55,59,61,67,71,73,77]

— Мастер пшеницы
источник

4

n=6, a=15это первый интересный тестовый пример.

— Нил

6

Это первое место, где не шаблон «a является n-простым, если n≤a <2n или (a≥2n и a является простым)», ломается.

— Миша Лавров

2

«Числа больше 2 являются простыми, если они не делятся на меньшее простое число». - Это определение позволяет любому числу быть простым. Может быть , вы хотите сказать , тогда и только тогда вместо если ?

5

@ThePirateBay Я не имею в виду точный математический смысл слова if. Я собираюсь оставить это.

— Пшеничный волшебник

1

@JeppeStigNielsen Это не очень сложно доказать. Все составные числа, которые являются n-простыми, должны иметь только простые множители, которые меньше, чем n. Мы также знаем, что никакое подмножество их факторов не может иметь произведение больше n, потому что наше число будет делиться на это. Таким образом, каждое n-простое число является либо 2-простым, либо произведением 2 чисел, меньших, чем n. Существует только конечное число пар чисел, меньших, чем n, поэтому существует только конечное число составных n-простых чисел. Надеюсь, это имеет смысл, мне пришлось сокращать, чтобы уместить это в комментарии.

— Пшеничный волшебник

9

Haskell , 45 байт

n!a=not$any(n!)[x|x<-[n..a-1],mod a x<1]||n>a

Попробуйте онлайн!

Я определил хорошую рекурсивную функцию (!):

n!aпроверяет , является ли какой - либо фактор a, в диапазоне [n,a-1], является n-prime. Тогда это сводит на нет результат. Это также гарантирует, чтоn>a

— H.PWiz
источник

Вот немного соревнования

— Волшебник Пшеницы

@WheatWizard Я надеялся, что кто-нибудь опубликует более короткое решение :)

— H.PWiz

6

Python 2 , 39 37 байт

Спасибо Халварду Хаммелю за -2 байта.

f=lambda n,i:n==i or i>i%n>0<f(n+1,i)

Попробуйте онлайн!

— овс
источник

4

Python 3 , 45 байт

lambda i,k:(i>k)<all(k%r for r in range(i,k))

Попробуйте онлайн!

Как это работает

В качестве входных данных используются два целых числа, i и k . Сначала проверяется, если k ≥ i . Затем генерирует диапазон [i, k) и для каждого целого числа N в этом диапазоне проверяет, является ли N взаимно простым с k . Если оба условия выполнены, то k является i- простым числом.

— Мистер Xcoder
источник

Вы не можете использовать &вместо andи >=iвместо >i-1?

— Пшеничный волшебник

@WheatWizard >=i по-прежнему 4 байта (из-за пробела).

— Нил

@Neil Если вы переодеваетесь, &вам не нужно место.

— Пшеничный волшебник

4

Шелуха , 6 5 байт

εf≥⁰Ḋ

Попробуйте онлайн! или посмотреть результаты до 80 .

Спасибо Лео за -1 байт.

объяснение

εf≥⁰Ḋ  Inputs are n and k.
    Ḋ  Divisors of k.
 f     Keep those that are
  ≥⁰   at least n.
ε      Is the result a one-element list?

— Zgarb
источник

4

R , 44 37 байт

function(a,n)a==n|a>n&all(a%%n:(a-1))

Попробуйте онлайн!

-7 байт благодаря Джузеппе

Возвращает, TRUEесли

aравно nили ( a==n|)
aбольше чем n и ( a>n&) для каждого числа k от nдо a-1, aне делится на k ( all(a%%n:(a-1)))

Возвращает FALSEиначе

— duckmayr
источник

Добро пожаловать в PPCG! Отличный первый ответ!

— FantaC

3

J, 30 байт

>:*(-{1=[:+/0=[:|/~]+i.@[)^:>:

Попробуйте онлайн!

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

Я изначально все испортил и не учел левых аргументов меньше, чем начальное простое число. Я несколько недоволен длиной моего решения сейчас.

объяснение

Позвольте xбыть левый аргумент (значение для проверки) и yбудет правым аргументом (начальное простое число).

>:*(-{1=[:+/0=[:|/~]+i.@[)^:>:
                          ^:>:  Execute left argument if x >= y
                     i.@[         Create range [0..x]
                   ]+             Add y to it (range now: [y..x+y])
                |/~               Form table of residues
            0=                    Equate each element to 0
          +/                      Sum columns
      1=                          Equate to 1
    -{                            Take the element at position x-y
>:*                             Multiply by result of x >= y

Заметки

Элемент в позиции x-yявляется результатом тестирования на примитивность для x(так как мы добавили yв исходный диапазон).

Умножение на x >: yгарантирует, что мы получим значение Falsey ( 0) xменьше, чем y.

— капуста
источник

3

JavaScript (ES6), 33 32 30 байт

Принимает ввод в синтаксисе карри (n)(a). Возвращает логическое значение.

n=>p=(a,k=a)=>k%--a?p(a,k):a<n

демонстрация

Показать фрагмент кода

let f =

n=>p=(a,k=a)=>k%--a?p(a,k):a<n

for(n = 2; n <= 12; n++) {
  for(a = n, P = []; P.length < 31; a++) {
    f(n)(a) && P.push(a);
  }
  O.innerText += 'n=' + n + ': ' + P.join(',') + '\n';
}

<pre id=O></pre>

Развернуть фрагмент

— Arnauld
источник

3

Haskell , 30 байт

2 байта сэкономлено благодаря идее H.PWiz, заимствованной из ответа flawr

n!a=[1]==[1|0<-mod a<$>[n..a]]

Попробуйте онлайн!

Хорошо, так как это было давно, и единственный ответ на Haskell до сих пор - 45 bty, я решил опубликовать свой собственный ответ.

объяснение

Эта функция проверяет, что единственное число между n и a , на которое делится a, является само собой.

Теперь в определении упоминаются только n- простые числа, меньшие чем a , так почему же мы проверяем все эти дополнительные числа? Не возникнут ли у нас проблемы, когда a делится на некоторую n- композицию, большую чем n ?

Мы не будем этого делать, потому что если n- композит больше n, он должен делиться на меньший n- простой по определению. Таким образом, если он делит, то должен и меньший n -прайм.

Если a меньше n [n..a] , то, []следовательно, не может быть равным, что [1]приводит к сбою проверки.

— Мастер пшеницы
источник

1

Желе , 8 байт

rṖ⁴%$Ạ×<

Попробуйте онлайн!

— Caird Coneheringaahing
источник

1

Пип , 23 19 14 байт

b>=a&$&b%(a,b)

Кратчайший метод - это порт ответа г-на Ксодера на Python . Принимает наименьшее простое число и число для проверки в качестве аргументов командной строки. Попробуйте онлайн!

— DLosc
источник

1

C, 55 байтов

f(n,a,i){for(i=a;i-->n;)a%i||f(n,i)&&(i=0);return-1<i;}

Попробуйте онлайн!

53 байта, если допустимо несколько возвращаемых значений:

f(n,a,i){for(i=a;i-->n;)a%i||f(n,i)&&(i=0);return~i;}

Попробуйте онлайн!

— Steadybox
источник

1

постоянный ток , ₄₀ ₃₄ 37 байт

[0p3Q]sf?se[dler%0=f1+dle>u]sudle>u1p

Я бы включил ссылку TIO, но TIO, похоже, содержит неправильное распределение, dcпоскольку в моей системе это работает так, как задумано, но Qкоманда работает неправильно на TIO. Вместо этого вот ссылка на bashполигон с правильно работающей версией dc:

Демо Это!

— Р. Кап
источник

1

APL (Дьялог) , 24 байта

{⍵∊o/⍨1=+/¨0=o|⍨⊂o←⍺↓⍳⍵}

Попробуйте онлайн!

Как?

⍳⍵- 1дляa

o←⍺↓- nчтобы aсохранитьo

o|⍨⊂o- по модулю каждого предмета oс каждым предметом вo

0=- проверить, где он равен 0(делит)

+/¨ - сумма количества делений

1= - если у нас есть только один, то число делится только на себя

o/⍨ - так что мы храним эти случаи

⍵∊- находится aв этом остаточном массиве?

— Уриэль
источник

0

JavaScript (Node.js) , 27 байт

i=>f=n=>i==n||i>i%n&&f(n+1)

Попробуйте онлайн!

Порт моего Python-ответа, принимает входные данные в синтаксисе карри: m(number)(first prime)

— овс
источник

0

JavaScript ES5, 34 байта

for(a=i=(p=prompt)();a%--i;);i<p()

— l4m2
источник

0

Добавить ++ , 20 байт

L,2Dx@rBcB%B]b*!!A>*

Попробуйте онлайн!

L,   - Create a lambda function
     - Example arguments:  [5 9]
  2D - Copy below; STACK = [5 9 5]
  x  - Repeat;     STACK = [5 9 [9 9 9 9 9]]
  @  - Reverse;    STACK = [[9 9 9 9 9] 5 19] 
  r  - Range;      STACK = [[9 9 9 9 9] [5 6 7 8 9]]
  Bc - Zip;        STACK = [[9 5] [9 6] [9 7] [9 8] [9 9]]
  B% - Modulo;     STACK = [4 3 2 1]
  B] - Wrap;       STACK = [[4 3 2 1]]
  b* - Product;    STACK = [24]
  !! - Boolean;    STACK = [1]
  A  - Arguments;  STACK = [1 5 9]
  >  - Greater;    STACK = [1 1]
  *  - Product;    STACK = [1]

— Caird Coneheringaahing
источник

Различные способы определения простых чисел

задача

тесты

Haskell , 45 байт

Python 2 , 39 37 байт

Python 3 , 45 байт

Как это работает

Шелуха , 6 5 байт

объяснение

R , 44 37 байт

J, 30 байт

объяснение

Заметки

JavaScript (ES6), 33 32 30 байт

демонстрация

Haskell , 30 байт

объяснение

Желе , 8 байт

Пип , 23 19 14 байт

C, 55 байтов

постоянный ток , 40 34 37 байт

APL (Дьялог) , 24 байта

JavaScript (Node.js) , 27 байт

JavaScript ES5, 34 байта

Добавить ++ , 20 байт

постоянный ток , ₄₀ ₃₄ 37 байт