Nhiệm vụ

Viết chương trình hoặc hàm, khi thông qua một đầu vào số x, in hoặc trả về các số nguyên tố bên dưới căn bậc hai của x¹ không phải là các yếu tố của x.

Ví dụ

Gọi f(x)hàm là:

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

Quy tắc thưởng

• Bạn có thể sử dụng bất kỳ nội dung nào mà ngôn ngữ của bạn cung cấp.
• Chương trình của bạn phải hỗ trợ xđầu vào cao như giới hạn trên được xác định bởi ngôn ngữ của bạn.

¹ Sử dụng căn bậc hai như chỉ các số nguyên tố bên dưới căn bậc hai thực sự có thể được tham gia trong các yếu tố của x. Nếu không thực hiện hạn chế này, số lượng lớn hơn sẽ có rất nhiều số in thừa.

Jelly, 6 byte trong bảng mã của Jelly

½ÆRḟÆf

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

Giải trình:

½Æ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 byte

X^ZqGYfX-

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

Giải trình

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 byte

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

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

MATLAB, 57 54 byte

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

Khá đơn giản, có được một loạt các số nguyên tố lên đến sqrt (p) sau đó loại bỏ bất kỳ yếu tố nào cũng là yếu tố của p. In đầu ra của dòng cuối cùng theo mặc định vì dấu chấm phẩy bị tắt.

Bình thường, 10 byte

fP_T-S@Q2P

Một chương trình lấy đầu vào của một số và in một danh sách.

Bộ kiểm tra

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

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 byte

tLDpϹfK

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

Giải trình

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

PHP, 76 byte

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

sử dụng giải pháp is_prime của tôi được chơi với giá $ n> 1

lấy đầu vào từ đối số dòng lệnh. Chạy với -r.

Toán học, 46 byte

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

Chức năng ẩn danh. Lấy một số làm đầu vào và trả về một danh sách các số làm đầu ra. Ký tự Unicode là U + 2223 DIVIDES cho \[Divides].

Ruby, 55 byte

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

Một câu trả lời khá lười biếng bằng cách sử dụng hàm liệt kê nguyên tố dựng sẵn.

Kỳ quan , 14 byte

@(_> > ^#0.5)P

Sử dụng:

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

Lấy các mục từ một danh sách vô hạn các số nguyên tố trong khi mục nhỏ hơn căn bậc hai của đối số.

Pyke, 10 byte

,BS#_P)QP-

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

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

PowerShell v2 +, 71 byte

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

Giải pháp lặp lại. Đưa đầu vào $nvà tạo một phạm vi từ 1đến Sqrt($n)(lưu ý rằng toán tử phạm vi sẽ ngầm định kết thúc phần trên thành một [int]phần sẽ thực hiện Làm tròn Ngân hàng theo mặc định). Sau đó sử dụng |?{...}(các Where-Objectnhà điều hành, hoạt động như một bộ lọc) để kéo ra những con số mà $n%$_không phải là zero (ví dụ, bất kỳ còn lại để các phương tiện modulo nó không phải là một yếu tố, và bất kỳ khác không là truthy) -andcác kiểm tra thủ regex thông thường là$true . Những cái còn lại trên đường ống, và đầu ra là ẩn.

Ví dụ

(với một số định dạng bổ sung để tăng đầu ra)

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 - Điều này sẽ thất bại trên các phiên bản trước nếu đầu vào lớn hơn xung quanh 2500000000, bởi vì ..nhà điều hành phạm vi chỉ có thể hỗ trợ tối đa 50.000 mặt hàng. Nhưng, vì giá trị đó lớn hơn [int]giá trị tối đa của kiểu dữ liệu mặc định , 2147483647nên tôi cho rằng điều đó là ổn. Trên máy của tôi, PSv4 Win8.1, tuy nhiên, tôi có thể tăng cao hơn, nhưng tôi không thể tìm thấy tài liệu giải thích sự khác biệt.

JavaScript (ES6), 79 76 byte

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

Dựa trên chức năng kiểm tra tính nguyên thủy đệ quy của tôi . Tôi cảm thấy nên có một vài cách để đơn giản hóa việc này, nhưng tôi không thể hiểu làm thế nào ...

Kiểm tra đoạn

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>

Octave, 44 byte

Câu trả lời này được lấy cảm hứng từ câu trả lời MATLAB của MattWH , nhưng tôi đã đánh golf nó bằng một số tính năng dành riêng cho Octave.

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

Đây là một chức năng ẩn danh có đầu vào x. Octave có phép gán và lập chỉ mục biến nội tuyến cho phép ytrước tiên được tạo trong hàm (không thể có trong MATLAB), sau đó được sử dụng như một phần của mặt nạ logic được tạo bởi ismember(một lần nữa, không thể thực hiện theo cách này trong MATLAB).

Perl 6 , 37 byte

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

Mở rộng:

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

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

Điều này sẽ chỉ thực hiện một lần, sau đó bạn cần bỏ bảng tạm thời để thực hiện lại trong cùng một trình soạn thảo

DROP TABLE #

Tôi đã tạo một phiên bản để kiểm tra nó, nó dài hơn một chút vì các quyền trực tuyến để tạo bảng không khả dụng. Vì lý do tương tự, nó không cần bảng thả mặc dù.

Dùng thử trực tuyến

R, 58 63 byte

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

Vòng lặp trên tất cả các giá trị từ 2 đến sqrt(x)và kiểm tra xem chúng có phải là số nguyên tố với numbersgói không. x%%itính toán x mod iđó là 0 -> Falsenếu ilà một ước củax và >0 -> Truenếu ikhông.

+5 byte vì numbers::Primes(n)hàm không cho phép số thập phân, trong khi 2:sqrt(x)không hoạt động, đã thêm kiểm tra nguyên tố vào ifcâu lệnh.

Haskell, 55 54 byte

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

Chủ yếu là hiểu đơn giản danh sách lồng nhau. GCD thực hiện hai vai trò, kiểm tra xem các số dưới y có phải là nhân tố của y hay không và cũng kiểm tra xem y có phải là nhân tố của x không.

Tách ra một chút:

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

Võng mạc , 69 66 byte

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

In các số nguyên tố trên các dòng riêng biệt, từ lớn nhất đến nhỏ nhất.

Hãy thử trực tuyến!(Mất khoảng 10 giây do hai trường hợp thử nghiệm gần nhất. Đầu trang và chân trang cho phép bộ thử nghiệm tách biệt nguồn cấp dữ liệu và chuyển đổi đầu ra thành phân tách bằng dấu phẩy để dễ đọc.)

Giải trình

.+
$*

Chuyển đổi đầu vào thành unary.

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

Điều này chuẩn bị căn bậc hai của đầu vào, cách nhau bởi :. Căn bậc hai được tính dựa trên thực tế là bình phương của ncũng là tổng của các nsố nguyên lẻ đầu tiên . Chúng ta có thể ghép các số nguyên lẻ liên tiếp với tham chiếu chuyển tiếp (11\1|^1). Trong quá trình, nhóm sẽ được sử dụng chính xác nthời gian, trong đó nsố lớn nhất có hình vuông phù hợp với đầu vào.

Chúng tôi chèn một đại diện đơn nhất của số này với $#1$*1, theo sau là dấu hai chấm và chính nó khớp.

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

Điều này phù hợp với tất cả các số nguyên tố còn thiếu phù hợp với căn bậc hai. Phát hiện nguyên tố dựa trên biểu thức kiểm tra số nguyên tố chuẩn , và sau đó chúng tôi chỉ cần đảm bảo rằng số nguyên tố chúng tôi vừa chụp không phân chia đầu vào với giao diện thứ hai. Bằng cách sử dụng &tùy chọn, chúng tôi có được các kết quả trùng lặp để đảm bảo rằng chúng tôi có được tất cả các số nguyên tố.

M%`1

Điều này chuyển đổi từng dòng (tức là mỗi số nguyên tố bị thiếu) trở lại thập phân bằng cách khớp với số 1s. Vấn đề duy nhất là cái này chèn số 0 nếu không tìm thấy số nguyên tố bị thiếu nào cả.

^0

Vì vậy, giai đoạn này loại bỏ số 0 đó nếu nó được thêm vào.