C, 54 bytes

i;main(j){for(scanf("%d",&i);i%++j;);putchar(49^j<i);} 

• Must be run without parameters, so j is initialized to 1.
• Reads from standard input.
• Prints 1 for primes, 0 for composites (no newline).
• Could save 2 bytes with unprintable output - I'm not sure if \x00 and \x01 qualify as falsy/truthy.

brainfuck, 208 202 bytes

This is the code I wrote for my Sesos answer. See that answer for a detailed explanation.

This code assumes input fits in a single cell. Attempting to take input from an empty file must set the cell to zero. It works on an unbounded tape with no wrapping, including one that can go negative. It works for all positive numbers. Output will be a byte with a value of 0 or 1.

[->+>+<<]++>[-<->]+<[>-<,]>[->+<]>[[->>>+<<<]>>>[->>>+<<<<<<+>>>]>>>-]<<<<<<+[<<<<<<]>>>>>>[-<+>]++[<[->>>+<<<]>>>[->>>+<<<<<<+>>>]>>>>][[->-[>+>>]>[+[-<+>]>+>>]<<<<<]<<<<<<]>>>>>>>>[>]>[<+>,]+<[>-<-]>. 

RPN, 16 bytes

lambda x isprime 

This define a function checking the primality of it's argument.

Call like this:

<number> lambda x isprime eval 

Nim, 70 56 bytes

import os,math let x=1.paramStr.len echo fac(x-1)^2mod x 

Uses Wilson's theorem; that is, x is prime if (x - 1)!² mod x is 1.

Takes input in unary (any character) via the first command-line argument. Outputs 1 if the input is prime, and 0 otherwise. To test:

$ nim c prime.nim $ ./prime 11111111 0 $ ./prime 1111111 1 $ ./prime 1 0 

Note that according to the Nim os docs, this solution will not work on POSIX as paramStr isn't available for some reason.

PHP, 70 65 bytes

for($i=2;$i<$n=$argv[1];$i++)if(is_int($n/$i)?1:0){echo 0;break;} 

Empty output if the number is prime, print 0 if the number is not prime.

Not very original or best answer, but this is it...

Test online

Ruby, 33 bytes

A little longer than other solutions, but doesn't require flags:

require'prime';p$*[0].to_i.prime?

Can be run putting in a file, say prime.rb:

ruby prime.rb 97

Or directly on the command line:

ruby -e "require'prime';p$*[0].to_i.prime?" 97

Logy, 82 bytes

f[X]->X<2&1|X*f[X-1];p[&1]->0<0;p[X]->f[X-1]%X==X-1;main[A]->print[p[atoi[A(1)]]]; 

I have no idea what I am doing.

Use Wilson's theorem.

Ungolfed code:

factorial[X] -> X < 2 & 1 | X*factorial[X - 1]; prime[&1] -> FALSE; prime[X] -> factorial[X - 1]%X == X - 1; main[Args] -> print[prime[atoi[Args(1)]]]; 

Batch, 121 bytes

set i=2 if %1%==2 exit /b if %1%==1 echo 0 :b set /a a=%1%%%i% set /a i=%i%+1 if %i%==%1% exit /b if %a%==0 echo 0 goto b 

Outputs 0 if it's no prime. This works only for inputs input > 0.

Dip, 1 byte

P 

Pretty self-explanatory...

Unary, 165192711826249169871716905363504385377479408598339493836 bytes

Well, basically 165192711826249169871716905363504385377479408598339493836 zeros. Here is a Java program that prints the actual program:

public class Main{ public static void main(String[]args){ for(BigInteger i = new BigInteger("165192711826249169871716905363504385377479408598339493836"),BigInteger j = BigInteger.ZERO;j.compareTo(i)!=0;j = j.add(BigInteger.ONE)){ System.out.println("0"); } } } 

This a port of this Brainfuck answer.

memes, 2 bytes

I decided to hop on the language train. Code:

}" 

Explanation:

} //Takes next input. " //Returns `True` or `False`, representing if the input is prime. 

Ceylon, 107 112

That was my first try:

shared void p(){if(exists a=process.readLine(),exists c=parseInteger(a)){print(!(2:c-2).any((d)=>c%d<1));}} 

This is a simple trial division of all numbers between 2 and c - 1, using the range operator : and the any method for iterating.

But this will also note 1 as prime. So here the corrected version:

shared void p(){if(exists a=process.readLine(),exists c=parseInteger(a)){print(1<c&&!(2:c-2).any((d)=>c%d<1));}} 

That works for numbers up to 2^63-1 ... and takes quite long for larger primes (or composite numbers with large factors) – I think it took about half a minute to confirm 2147483647 (=2^31-1) as prime.

The formatted version:

shared void p() { if (exists a = process.readLine(), exists c = parseInteger(a)) { print(1 < c && !(2 : c - 2).any((d) => c % d < 1)); } } 

I originally wrote the check as d.divides(c), but the modulo operator is so much shorter.

As a bonus, here is a variant for arbitrary size integers, though there is not really a point in using this due to the slowness.

import ceylon.math.whole { w=parseWhole, t=two, o=one } shared void q() { if (exists a = process.readLine(), exists c = w(a)) { print(c == t || !(t .. c - t).any((d) => c % d < o)); } } 

The : range operator needs an Integer (the number of elements) as a second argument, so we use the .. operator, which takes the same type as the first argument, i.e. here a Whole, as second argument (the upper limit). 2..c-1 is the same as 2:c-2 for large c, but this becomes an empty list for two (and a non-empty list for one), so we need a different exception here than in the Integer version. It becomes mainly longer due to the imports.

The space-reduced version has length 153:

import ceylon.math.whole{w=parseWhole,t=two,o=one}shared void q(){if(exists a=process.readLine(),exists c=w(a)){print(c==t||!(t..c-o).any((d)=>c%d<o));}} 

Maverick, 25 bytes

(1:(<>@-1)//$*)%<>@=<>@-1 

Try it online!

This is a pretty fun language IMO. Infix and esoteric.

(1:(<>@-1)//$*)%<>@=<>@-1 1: range from 1 to (<>@ first command line arg (<> called with no args) -1) minus 1 //$* folded over multiplication ( )% modulus <>@ the input = does the above equal <>@-1 the input minus 1? If so, yields prime 

Valyrio, 14 bytes

s∫main [ipo] 

Outputs 1 if the input is prime. Otherwise outputs 0.

Explanation

s∫ tells the interpreter to enter stack mode

main [ starts the main code block

i takes an input and evaluates it

p pushes 1 or 0 to the stack depending on primality

o outputs the top item on the stack

] ends the main code block

Racket 75 bytes

(let p((c 2))(cond[(> c(sqrt n))#t][(= 0(modulo n c))#f][else(p(+ 1 c))])) 

Ungolfed:

(define (f n) ; COMMENTS: (let loop ((c 2)) (cond [(> c (sqrt n)) #t] ; if no divisor found till sq root of number, it must be a prime [(= 0 (modulo n c)) #f] ; if divisor found, it is not a prime [else (loop (add1 c))] ; try with next number ))) 

Following version is longer but more efficient for checking larger numbers since it keeps & uses previously found prime numbers:

(λ(N)(define(p n(o'(2))(c 2))(cond[(> c n)o][(ormap(λ(x)(= 0(modulo c x)))o) (p n o(+ 1 c))][else(p n(cons c o)(+ 1 c))]))(= N(car(p N)))) 

Ungolfed version:

(p=subfunction to build prime number list till n; o= list of prime numbers found; c=current number being checked)

(define f (λ (N) (define (p n (o '(2)) (c 2)) (cond [(> c n) o] [(ormap (lambda(x) (= 0 (modulo c x))) o) (p n o (add1 c)) ] [else (p n (cons c o) (add1 c))])) (= N (first (p N))))) 

Testing:

(f 109) (f 10) (f 11) (f 12) (f 13) (f 49) (f 43) (f 57) (f 47) 

Output:

#t #f #t #f #t #f #t #f #t 

PHP, 43 39 54 44 43 bytes

improved my answer from stackoverflow:

for($i=$n=$argv[1];--$i&&$n%$i;);echo$i==1; 

Run with -r. prints 1 if argument is prime, empty string else.

loops $i down from $n-1 until it finds a divisor of $n; $n is prime if that divisor is 1.

6 bytes extra for the 1 case. almost happy.

√ å ı ¥ ® Ï Ø ¿ , 3 bytes

Ipo 

p is the primality test.

NO!, 34 bytes

This was taken from the NO! GitHub page. It isn't mine

NOOOOOOO?NOOOOOOOOOOO NOOOOOOOO?no 

Ruby 16+15 bytes

require 'prime';p->e{e.prime?} 

QBIC, 21 20 3 bytes (nc)

Since the purpose of the challenge is to build a catalog, I feel it's important to keep the QBIC post up-to-date with the current state of the language:

­?µ: 

Explanation:

? PRINT µ QBIC's prime test, returns -1 for primes, 0 otherwise : Read a number from the command line, insert that here The function is closed automatically because of EOF. 

Previously, at 20 bytes:

:[a|~a%b|\p=p+1}?p<3 

Simple trial divider. Every time b (the loop counter) cleanly divides a (our prime-candidate), p is increased. Primes will end with p at 2 (or p=1 for a=1). This then prints -1 for primes, and 0 for non-primes, which are QBasic default values for true and false resp.

Original entry, 21 bytes. This prints 1 for primes, and 0 for others. This feels more 'natural' to me than QBasic's default -1/0. Also, this only does slightly less than a/2 divisions for primes (and quits when it detects a non-prime), instead of doing a divisions regardlessly.

:[2,a/2|~a%b=0|_Xp}?q 

Explanation:

: Get the input number, 'a' [2,a/2| FOR(b=2, b<=(a/2), b++) ~a%b=0 IF a MOD b == 0 --> Clean division == no prime |_Xp THEN exit program, printing 'p' (which never gets set and is 0 by default) } Close all language constructs: IF/END IF, FOR/NEXT ?q We've made it through the FOR loop without division, N is prime. In QBIC, 'q' is auto-initialised to 1, '?' prints it. 

Add++, 14 17 bytes

D,f,@,P +? $f,x O 

Try it online!

10 bytes are boilerplate for the full program requirement.

Function, 7 bytes

D,f,@,P 

Fairly basic, just defines a function that performs a primality test

Built-in, 1 byte

P 

As functions and main code use both different memory models and different commands, this only works in function mode and so would be invalid.

cQuents, 3 bytes

?pz 

Try it online!

Explanation

? Mode ? (query) p Builtin: next prime after parameter z Previous item in sequence ) Implicit closing parenthesis 

Query mode returns true if the input is in the sequence, and false if it is not.

TI-BASIC, 37 bytes

Prompt N N=1 For(A,2,√(N Ans+not(fPart(N/A End not(Ans 

Prompts for N and displays 1 if N is prime or 0 otherwise.

Also in TI-BASIC:

• 12 bytes by Thomas Kwa
• 24 bytes by Zenohm

TI-BASIC (nspire), 15 bytes

f(n):=isPrime(n 

Uses the CAS isPrime() builtin. The environment by default adds an extra parenthesis on the end of the input, making it f(n):=isPrime(n) when the function is defined in the interpreter.

Pyth, 3 2 bytes

I can't see a simpler way of doing this. My ignorance continues to amaze me.

P_ 

Explanation (if it needs one):

P Prime function: factorization if positive, isPrime if negative _ Negate the implicit input 

Test suite

Python 3, 57 bytes

k=int(input());print(all(k%j for j in range(2,k))and k>1) 

I think it's pretty self-explanatory.

Funky, 39 bytes

n=>{o=1for(i=2;i<n;i++)o=o&0<n%i o&n>1} 

Try it online!

Common Lisp, 64 bytes

(print(=(loop as x from 1 to(setq n(read))count(=(rem n x)0))2)) 

Try it online!

57 bytes in Common Lisp REPL:

(=(loop as x from 1 to(setq n(read))count(=(rem n x)0))2) 

Groovy, 92 91

i=System.in.newReader().readLine()as int print i==2||i>1&&!(true in(2..i-1).collect{i%it<1}) 

Such a verbose way to read from stdin...

><>, 46 Bytes

i> :1\/ln; ~\?:-/^?(2l~ %$}:{<;n0/? l1- ?/1n;\ 

Takes input as an ascii character, prints 1 for primes, 0 for non-primes, including 1. Loops forever if input is 0 or negative.

How it works:

 > :1\ \?:-/ 

Fills the stack with integers between 0 and input, inclusive.

 /ln; ~ /^?(2l~ 

Removes the top two values on the stack, 0 and 1. Tests if the length of the stack is <2; if it is, the value is either 1 or 2. In either case, its truthy/falsy value is the length of the stack; print it. If the length is greater than 2, it continues to the next loop.

%$}:{<;n0/? l1- ?/1n;\ 

Duplicates the value being tested from the bottom of the stack. Test if it's divisible by the value at the top. If it is, print 0. Otherwise, check that the stack length is not 1. If it is, the value being tested is prime; print 1.

Edit:

Added on to this program a bit, as a part in my attempt to conquer as much of project euler as possible in ><>.

This is for Project Euler 7: Calculating the 10001st prime

a:::***31[\>?!/l1-?\]r1-:?!/r:nao1+70. \/{*::+1<0<\%$}:{ <~~ \:}(?!\/-1l \ ;nr\ \!?:-1:<\ ?!\~^.38 \] 1+70. 

Comes in at 130 Bytes, although I didn't try very hard to golf it. Pushes 10000 to the stack (since we start at 3), makes a new stack, runs the primality test on the number, starting at 3. If it's prime, decrement the counter and increase the value being tested. If its not prime, just increment the value.

The go-fish interpreter was a life saver for this--it ran orders of magnitude faster than fish.py.