Задание

Напишите программу или функцию, которая при пропуске числового ввода xпечатает или возвращает простые числа ниже квадратного корня из x¹ , которые не являются множителями x.

Примеры

Позвольте f(x)быть функция называется:

>>> f(4)
[]

>>> f(5)
[2]

>>> f(20)
[3]

>>> f(60)
[7]

>>> f(100)
[3, 7]

>>> f(10000)
[3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

Бонус Правила

• Вы можете использовать любые встроенные функции, которые предоставляет ваш язык.
• Ваша программа должна поддерживать xввод, превышающий верхнюю границу, определенную вашим языком.

¹ Использование квадратного корня в качестве только простых чисел ниже квадратного корня может быть фактически вовлечено в факторы x. Без этого ограничения у больших чисел будет много лишних напечатанных чисел.

Желе, 6 байтов в кодовой странице желе

½ÆRḟÆf

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

Объяснение:

½ÆRḟÆf
 ÆR    All primes less than or equal to
½      the square root of the input
   ḟ   but with the following removed:
    Æf All prime factors of {the input, by default}

MATL , 10 9 байт

X^ZqGYfX-

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

объяснение

X^    % Implicit input. Square root
Zq    % Array if primes up to that
G     % Push input again
Yf    % Array of prime factors
X-    % Set difference. Implicit display

Python 3 , 67 62 байта

f=lambda n,k=1,m=1:k*k<n and(m%k*n%k>0)*[k]+f(n,k+1,m*k*k)or[]

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

MATLAB, 57 54 байта

function h(p);a=primes(p^.5);a(~ismember(a,factor(p)))

Довольно просто, получает массив простых чисел до sqrt (p), а затем удаляет все, которые также являются факторами p. По умолчанию выводит вывод последней строки, поскольку точка с запятой не указана.

Pyth, 10 байт

fP_T-S@Q2P

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

Тестирование

Как это устроено

fP_T-S@Q2P   Program. Input: Q
fP_T-S@Q2PQ  Implicit input fill
f            Filter
     S@Q2    the 1-indexed range up to floor(sqrt(Q))
    -    PQ  with the prime factors of Q removed
 P_T         by primality
             Implicitly print

05AB1E , 8 байтов

tLDpϹfK

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

объяснение

tL        # range [1 ... sqrt(input)]
  DpÏ     # keep only primes
     ¹fK  # remove factors of input

PHP, 76 байт

for($n=1;++$n*$n<$x=$argv[1];){for($i=$n;$n%--$i;);if($i<2&&$x%$n)echo$n,_;}

использует мое решение is_prime для игры в гольф за $ n> 1

принимает входные данные из аргумента командной строки. Беги с -r.

Mathematica, 46 байт

Select[Prime@Range@PrimePi@Sqrt[a=#],!#∣a&]&

Анонимная функция. Принимает число в качестве ввода и возвращает список номеров в качестве вывода. Символ Unicode - это U + 2223 DIVIDES для \[Divides].

Рубин, 55 байт

require'prime'
->x{Prime.to_a(x**0.5).select{|n|x%n>0}}

Довольно ленивый ответ с использованием встроенного простого перечислителя.

Чудо , 14 байт

@(_> > ^#0.5)P

Использование:

(@(_> > ^#0.5)P)10

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

Пайк, 10 байт

,BS#_P)QP-

Попробуй это здесь!

,B         -    int(sqrt(input))
  S        -   range(1, ^+1)
   #_P)    -  filter(^, is_prime)
         - - ^.remove(V)
       QP  -  factors(input)

PowerShell v2 +, 71 байт

param($n)1..[math]::Sqrt($n)|?{$n%$_-and'1'*$_-match'^(?!(..+)\1+$)..'}

Итеративное решение. Принимает ввод $nи создает диапазон из1 до Sqrt($n)(обратите внимание, что оператор диапазона неявно приведёт верхний конец к[int] который по умолчанию будет выполнять округление Банкира). Затем используется |?{...}(на Where-Objectоператора, который действует как фильтр) , чтобы вытащить эти цифры , где $n%$_не равен нулю (то есть, любой остаток к модулю означает , что он не является фактором, и любой ненулевой является truthy)-and простое испытание обычно регулярное выражение является $true, Они остаются на конвейере, и вывод неявный.

Примеры

(с некоторым дополнительным форматированием, чтобы улучшить вывод)

PS C:\Tools\Scripts\golfing> 5,20,60,100,10000|%{"f($_)";(.\print-the-missing-primes.ps1 $_)-join', ';""}
f(5)
2

f(20)
3

f(60)
7

f(100)
3, 7

f(10000)
3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97

NB - Это не удастся на более ранних версиях, если вход больше, чем вокруг 2500000000, потому что.. оператор диапазона может поддерживать только до 50 000 элементов. Но, поскольку это больше, чем [int]максимальное значение типа данных по умолчанию ,2147483647 , я предполагаю, что все будет в порядке. На моей машине, PSv4 Win8.1, однако, я могу пойти выше, но я не могу найти документацию, объясняющую разницу.

JavaScript (ES6), 79 76 байт

f=(q,n=2,x=n)=>n*n<q?[...--x<2&&q%n?[n]:[],...x>1&&n%x?f(q,n,x):f(q,n+1)]:[]

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

Тестовый фрагмент

f=(q,n=2,x=n)=>n*n<q?[...--x<2&&q%n?[n]:[],...x>1&&n%x?f(q,n,x):f(q,n+1)]:[]

<input type="number" step=1 min=4 value=4 oninput="O.innerHTML='['+f(this.value)+']'"><br>
<pre id=O>[]</pre>

Октава, 44 байта

Этот ответ вдохновлен ответом MattWH на MATLAB , но я играл в гольф, используя некоторые особенности, характерные для Octave.

@(x)(y=primes(x^.5))(~ismember(y,factor(x)))

Это анонимная функция, которая принимает данные x. Octave имеет встроенное назначение переменных и индексацию, позволяющую yсначала создать функцию (это невозможно в MATLAB), а затем использовать как часть логической маски, созданной ismember(опять же, это невозможно сделать в MATLAB).

Perl 6 , 37 байт

{grep {$^a.is-prime&$_%$a},2.. .sqrt}

Expanded:

{   # bare block lambda with implicit parameter ｢$_｣

  grep
  {
    $^a.is-prime  # check if it is prime
    &             # and junction
    $_ % $a       # check if the input is not evenly divisible by it
  },
  2.. .sqrt          # Range of values up-to and including squareroot
}

TSQL, 130 байт

DECLARE @v int=10000

,@ INT=2SELECT 2p INTO #
g:INSERT # SELECT @ FROM # HAVING isnull(min(@%p),1)>0SET @+=1IF @*@<@v GOTO g
SELECT*FROM # WHERE @v%p>0

Это будет выполнено только один раз, затем вам нужно будет удалить временную таблицу для повторного выполнения в том же редакторе

DROP TABLE #

Я сделал версию для ее тестирования, она немного длиннее, потому что онлайн-разрешения для создания таблиц недоступны. По той же причине ему не нужна таблица удаления.

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

R, 58 63 байта

for(i in 2:sqrt(x<-scan()))if(x%%i&numbers::isPrime(i))print(i)

Перебирает все значения от 2 до sqrt(x)и проверяет, являются ли они простыми с numbersпакетом. x%%iвычисляет, x mod iчто 0 -> Falseесли iявляется делителем xи >0 -> Trueеслиi нет.

+5 байт, потому что numbers::Primes(n)функция не допускает десятичные дроби, хотя 2:sqrt(x)и работает, добавила первичную проверку в ifоператор.

Haskell, 55 54 байта

f x=[y|y<-[2..x],y*y<x,[z|z<-[1..y],gcd(z*x)y>1]==[y]]

В основном простые вложенные списки. GCD выполняет две роли: проверяет, являются ли числа ниже y факторами y, а также проверяет, является ли y фактором x.

Разместил немного:

f x = [ y|y<-[2..x],     y*y<x,     [z|z<-[1..y], gcd (z*x) y > 1] == [y] ]

Сетчатка , 69 66 байт

.+
$*
(11\1|^1)+
$#1$*1:$&
M!&`(?!(11+)\1+:)(1+):(?!\2+$)
M%`1
^0

Печать простых чисел в отдельных строках, от самых больших до самых маленьких.

Попробуйте онлайн!(Занимает около 10 секунд из-за последних двух тестовых случаев. Заголовок и нижний колонтитул включают отдельный набор тестов с переводом строки и преобразуют вывод в разделение запятыми для удобства чтения.)

объяснение

.+
$*

Преобразовать ввод в унарный.

(11\1|^1)+
$#1$*1:$&

Это добавляет квадратный корень ввода, разделенный :. Квадратный корень вычисляется на основе того факта, что квадрат nтакже является суммой первых nнечетных целых чисел. Мы можем сопоставить последовательные нечетные целые числа с прямой ссылкой (11\1|^1). При этом группа будет использоваться ровно в тот nраз, когдаn наибольшее число, квадрат которого вписывается во вход.

Мы вставляем унарное представление этого числа с $#1$*1последующим двоеточием и самим соответствием.

M!&`(?!(11+)\1+:)(1+):(?!\2+$)

Это соответствует всем отсутствующим простым числам, которые вписываются в квадратный корень. Обнаружение простых чисел основано на стандартном регулярном выражении проверки простых чисел , и затем мы просто проверяем , что только что полученное простое число не делит входные данные со вторым прогнозом. Используя эту &опцию, мы получаем перекрывающиеся совпадения, чтобы обеспечить получение всех простых чисел.

M%`1

Это преобразует каждую строку (т. Е. Каждое пропущенное простое) обратно в десятичную, сопоставляя число 1s. Единственная проблема заключается в том, что он вставляет ноль, если не было найдено пропущенных простых чисел.

^0

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