Nhiệm vụ rất đơn giản: chương trình của bạn đọc một số nguyên làm đầu vào và in xem nó có phải là số nguyên tố hay không. Bạn có thể in "có / không", "đúng / sai" hoặc bất cứ điều gì xác định rõ ràng kết quả.

Thách thức là, mã phải làm việc với các hàng và cột được hoán vị.

Để loại trừ giải pháp rõ ràng (giải pháp "đơn giản" ngắn nhất được lặp lại theo chiều dọc với việc sử dụng các nhận xét), số liệu này hơi khác một chút so với môn đánh gôn thông thường:

Vì định dạng rất quan trọng trong thử thách này , kích thước mã được đo trong khu vực của hình chữ nhật nhỏ nhất mà mã phù hợp. Nói cách khác, khoảng trắng sẽ được tính và các dòng phải được điền vào có độ dài bằng nhau (bạn không phải thực sự làm điều đó khi bạn đăng giải pháp, vì đơn giản). Ví dụ

int main()   
{            
    return 0;
}            

sẽ có kích thước 4 * 13 = 52, _{(và rõ ràng là nó không phù hợp với một trong hai tiêu chí: phát hiện chính và chuyển tiếp.)}

Kích thước nhỏ nhất thắng.

Bạn có thể sử dụng bất kỳ ngôn ngữ và bất kỳ chức năng thư viện nào trừ khi mục đích duy nhất của chức năng đó là tìm kiếm, tạo hoặc phát hiện các số nguyên tố.

Biên tập:

Mặc dù người chiến thắng có thể là giải pháp Golfscript, tôi sẽ trao phần thưởng 50 điểm cho giải pháp C hoặc C ++ tốt nhất!

GolfScript, 13 × 1

~.,2>{1$\%!}?

GolfScript đình công một lần nữa!

Lặp lại đầu vào nếu nó là số nguyên tố, nếu không thì in đầu vào được nối với ước số nhỏ nhất của nó. Vâng, tôi biết rằng điều đó đã kéo dài định nghĩa về "bất cứ điều gì rõ ràng xác định kết quả", nhưng làm bất cứ điều gì người hâm mộ sẽ tốn thêm một vài ký tự. Nếu bạn muốn đầu ra đẹp hơn, nối thêm ba ký tự ;]!vào mã mang lại 1cho các số nguyên tố và 0cho các số tổng hợp.

Thuật toán này thực sự không hiệu quả, chỉ cần phân chia thử nghiệm vũ lực từ 2 đến n -1. Hầu hết các toán tử GolfScript chỉ là các ký tự đơn, vì vậy mã này hoạt động tốt như được chuyển đổi. Mặc dù vậy, thật khó chịu, toán tử gán :không cho phép khoảng trắng giữa chính nó và mục tiêu của nó, vì vậy tôi phải làm điều này hoàn toàn không có biến.

C, 2 * 70 2 * 60

In ycho số nguyên tố, không có gì khác.
EDIT : Thay đổi mã để lưu 10 ký tự. Phải được chạy mà không có thông số (vì vậy m=1).

main(m,n){for(scanf("%d",&n);n%++m&&n>1;);n-m||puts("y");}/*
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/ 

Phương pháp xử lý chuyển vị khá chung chung và có thể được áp dụng cho bất kỳ chương trình nào.
Nó dựa trên việc chuyển đổi này:

abcd/*
\\\\*/

Về điều này:

a\
b\
c\
d\
/*
*/

Và cả hai đều có nghĩa đơn giản abcd.

C - 13x13

Đọc đầu vào từ stdin và in một 1số nguyên tố và một 0số nguyên tố không.

////m(i;(a=)<
////aans")a;2
//:Di)tc%;;p)
//O n{ adfau+
main//bn"o%t4
(a){///f,r-c8
int b///&(-h)
;scanf///bba;
("%d",&///;r}
a);for(b///( 
=a;a%--b;//( 
);putchar((b 
<2)+48);}    

chỉnh sửa: biên dịch với gcc và clang ngay bây giờ, các trình biên dịch khác chưa được thử nghiệm

C, 12x12 ký tự

Một giải pháp hai chiều, không giống như câu trả lời khác của tôi , dựa trên cùng một mã (và giống như nó, in ycho số nguyên tố, không có gì cho tổng hợp).
Cấu trúc tương tự như câu trả lời của Quasimodo , nhưng mã của tôi ngắn hơn và tôi nghĩ rằng việc sử dụng comemnts của tôi hiệu quả hơn một chút, vì vậy tôi có thể phù hợp với 12x12.

////m()s";np
////am{c%n>u
////i,fad%1t
////nnon"+;s
main//rf,+)(
(m,n//((&m;"
){for(//n&ny
scanf(//)&-"
"%d",&n)//m)
;n%++m&&//|;
n>1;);n-m|| 
puts("y"); }

Perl, 14 x 14

Tôi nghĩ rằng tôi đang hiểu rõ điều này. Chỉ định số làm đối số dòng lệnh, đầu ra 0hoặc 1. Có lẽ nhiều phòng để cải thiện.

$   n=pop;$p|=
 !  ($n%$_)for
  2 ..$n/2;   
   print!$p+m~
n(.r          
=$.i          
pn$n          
o%nt          
p$/!          
;_2$          
$);p          
pf +          
|o m          
=r ~          

Q

Bình luận lạm dụng cho một giải pháp đối xứng, nhân vật không hiệu quả.

/{/////////////////////////////////
{(~)any 0=mod[x;2+(!)x-2]}"I"$(0:)0
/~
/)
/a
/n
/y
/ 
/0
/=
/m
/o
/d
/[
/x
/;
/2
/+
/(
/!
/)
/x
/-
/2
/]
/}
/"
/I
/"
/$
/(
/0
/:
/)
/0

Lấy đầu vào từ STDIN, trả về một boolean.

Thạch , vuông 2x2

PÆ
ÆP

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

Tôi nghĩ rằng tôi có phần chuyển vị chính xác, và nếu vậy, phiên bản chuyển đổi của phần này là

PÆ
ÆP

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

(cùng mã)

05AB1E , 1x5 1x3 ( 5 3 byte )

Đây không phải là một chương trình lớn; mỗi dòng là một chương trình thay thế riêng biệt để giải quyết kiểm tra chính (không sử dụng hàm dựng sẵn).

ÑPQ
ÒgΘ
ÒQP
ÕαΘ
fQO
fs¢
f`Q

-2 byte nhờ Grimy .

Các khoảng trắng ở giữa các dòng là no-op trong 05AB1E và vì tôi chỉ sử dụng các lệnh 1 byte, nên điều này hoạt động tốt sau khi chuyển vị.

Đầu ra 1/ 0cho sự thật / falsey tương ứng.

Hãy thử cái đầu tiên trực tuyến hoặc xác minh thêm một số trường hợp thử nghiệm cho tất cả chúng (với eval dựng sẵn .V) .
Transposed: Hãy thử cái đầu tiên trực tuyến .

Giải trình:

Ñ    # Get a list of all divisors of the (implicit) input-integer
     # (which would be only 1 and the integer itself for primes)
 P   # Take the product of that list
  Q  # And check if it's equal to the (implicit) input-integer

Ò    # Get a list of all prime factors of the (implicit) input-integer 
 g   # Get the amount of those prime factors by taking the length of the list
  Θ  # Check if that's equal to 1 (so only itself is a prime factor)

Ò    # Get a list of all prime factors of the (implicit) input-integer including duplicates
 Q   # Check for each if it's equal to the (implicit) input-integer
     # (1 if truthy; 0 if falsey)
  P  # Take the product of those checks (resulting in either 1 or 0 as well)

Õ    # Get the Euler totient of the (implicit) input-integer
 α   # Take the absolute difference with the (implicit) input-integer
  Θ  # Check if that's equal to 1

f    # Get a list of all prime factors of the (implicit) input-integer without duplicates
 Q   # Check for each if it's equal to the (implicit) input-integer
  O  # And take the sum of that (resulting in either 1 or 0)

f    # Get a list of all prime factors of the (implicit) input-integer without duplicates
 s   # Swap to get the (implicit) input-integer
  ¢  # And count how many time it occurs in the list

f    # Get a list of all prime factors of the (implicit) input-integer without duplicates
 `   # Dump all the content of this list onto the stack
  Q  # Check if the top two values are equal, or if only a single value is present, it will
     # use the (implicit) input-integer as second value

     # For all these program the same applies at the end:
     # (implicitly output the result with trailing newline)

LƯU Ý: Nếu chỉ có giá trị trung thực / falsey là hợp lệ và không nhất thiết phải khác biệt, Òghoặc Õαcó thể được sử dụng làm 2-byters hợp lệ, vì chỉ có sự 1thật trong 05AB1E và mọi thứ khác đều là falsey: Hãy thử cả hai chúng cho một số trường hợp thử nghiệm .

Nếu nội dung được cho phép, một đơn psẽ có hiệu lực: Dùng thử trực tuyến hoặc xác minh thêm một số trường hợp thử nghiệm .

Bùa mê , 7 × 1

v̀i'PA@

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

Runic quan tâm không phải cho nỗ lực yếu của bạn trong sắp xếp lại nguồn! Tuân thủ yêu cầu vẫn hoạt động sau khi có chi phí chuyển đổi nguồn +3 byte (chiều rộng hình chữ nhật +2) cho công cụ sửa đổi phản xạ và điểm vào.

Chuyển đổi hoặc hoán vị, nhưng để lại ký tự kết hợp gắn liền với cha mẹ của nó .

dzaima / APL, 8 × 9 = 72

{t←0,1↓⍳⍵
 ←⍵∊∘.×⍨t
 0∊      
 ,∘      
 1.      
 ↓×      
 ⍳⍨      
 ⍵t     }

Hãy thử bản gốc hoặc hoán chuyển !

Kích thước Python 3 , 28 x 28

lambda i:i>1 and           \
all(i%j for j in range(2,i))
ml="""                     "
b("                        "
di"                        "
a%"  
 j   
i    
:f   
io   
>r   
1    
 j   
a    
ni   
dn   
     
 r   
 a   
 n   
 g   
 e   
 (   
 2   
 ,   
 i   
 )   
\)"""

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

JavaScript (Node.js) , 26 25x5

n=>!( P/**//*-
= * P =* /** -         r 
>**/= r=>n%--r?P(r):~-r)(
/*////=  %  *        /*/n
*1 )//>*/   /        *//)

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

Chuyển đổi:

n=>/*
= **1
>**/ 
! //)
(P=//
   //
P=r=>
/*= *
* > /
*/n% 
/*%  
/*-  
* -*/
--r  
  ?  
  P  
  (  
  r  
  )  
  :  
  ~  
  -/*
  r*/
 r)//
  (n)

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

APL (Dyalog Unicode) , 10x11

{⍵∊∘.×⍨1↓⍳⍵          
 ∊          
 ∘          
 .          
 ×          
 ⍨          
 1          
 ↓          
 ⍳          
 ⍵         }

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

Sửa lỗi chức năng để tuân thủ các thông số kỹ thuật. Cảm ơn @ Adám đã ủng hộ.

Trả về 0 cho sự thật, 1 cho giả .

Làm sao

{⍵∊∘.×⍨1↓⍳⍵ ⍝ Dfn. everything below this is a noop up until closing the brace
         ⍳⍵ ⍝ Range [1..arg]
       1↓   ⍝ Dropping the first element (yields [2..arg])
   ∘.×⍨     ⍝ Multiplication table for each element in the vector
 ⍵∊         ⍝ Check if the argument is in the table.

Phiên bản chuyển đổi là chính xác như nhau.