[Question]
  [
Write a program that will test the primality of a specified number, and give the output as a Boolean value (True is prime). Your prime test can (but doesn't have to) be valid for the number 1. 
Here's the catch: your program itself has to sum to a prime number. Convert every character (including spaces) to its Unicode/ASCII value ([table](http://www.theasciicode.com.ar/american-standard-code-information-interchange/ascii-codes-table.png)). Then, add all those numbers together to get the sum of your program.
For example, take this not-so-great program I wrote in Python 3.3:
```
q=None
y=int(input())
for x in range(2,int(y**0.5)+1):
    if y%x==0:
        q=False
if not q:
    q=True
print(q)
```
If you convert all the characters to their corresponding Unicode/ASCII value, you get:
```
113 61 78 111 110 101 10 121 61 105 110 116 40 105 110 112 117 116 40 41 41 10 102 111 114 32 120 32 105 110 32 114 97 110 103 101 40 50 44 105 110 116 40 121 42 42 48 46 53 41 43 49 41 58 10 32 32 32 32 105 102 32 121 37 120 61 61 48 58 10 32 32 32 32 32 32 32 32 113 61 70 97 108 115 101 10 105 102 32 110 111 116 32 113 58 10 32 32 32 32 113 61 84 114 117 101 10 112 114 105 110 116 40 113 41 
```
You can then find the sum of those numbers manually or with your own program. This specific program sums to 8293, which is a prime number.
Of course, this is Code Golf, so the smaller you can make your program, the better. As pointed out by other users, this program is not very golfy.
A few rules:
Valid inputs include STDIN and prompts (no functions, it's just a way to add free extra code). Spaces are permitted, but only if they are crucial to the functionality of your program. Output must be an output, not just stored in a variable or returned (use print, STDOUT, etc.)
Flags can be used and should be counted literally, not expanded. Comments are not allowed. As for non-ASCII characters, they should be assigned to the value in their respective encoding. 
Make sure to list your program's size and the sum of the program. I will test to make sure programs are valid.
Good luck!
Here is a snippet to count the sum of your program and check if it is prime:
```
function isPrime(number) { var start = 2; while (start <= Math.sqrt(number)) { if (number % start++ < 1) return false; } return number > 1; } var inp = document.getElementById('number'); var text = document.getElementById('input'); var out = document.getElementById('output'); function onInpChange() { var msg; var val = +inp.value; if (isNaN(val)) { msg = inp.value.toSource().slice(12, -2) + ' is not a valid number.'; } else if (isPrime(val)) { msg = val + ' is a prime number!'; } else { msg = val + ' is not a prime number.'; } out.innerText = msg; } function onTextChange() { var val = text.value; var total = new Array(val.length).fill().map(function(_, i) { return val.charCodeAt(i); }).reduce(function(a, b) { return a + b; }, 0); inp.value = '' + total; onInpChange(); } text.onkeydown = text.onkeyup = onTextChange; inp.onkeydown = inp.onkeyup = onInpChange;
```
```
body { background: #fffddb; } textarea, input, div { border: 5px solid white; -webkit-box-shadow: inset 0 0 8px  rgba(0,0,0,0.1), 0 0 16px rgba(0,0,0,0.1); -moz-box-shadow:  inset 0 0 8px  rgba(0,0,0,0.1), 0 0 16px rgba(0,0,0,0.1); box-shadow:  inset 0 0 8px  rgba(0,0,0,0.1), 0 0 16px rgba(0,0,0,0.1);  padding: 15px; background: rgba(255,255,255,0.5); margin: 0 0 10px 0; font-family: 'Roboto Mono', monospace; font-size: 0.9em; width: 75%; }</style><meta charset="utf-8"><style>/**/
```
```
<link href="https://fonts.googleapis.com/css?family=Roboto+Mono" rel="stylesheet"><textarea id="input" tabindex="0">Insert your (UTF-8 encoded) code here
Or directly input a number below</textarea><br><input id="number" value="6296" tabindex="1"><br><div id="output">6296 is not a prime number.</div>
```
  
[Answer]
## [hello, world!](https://github.com/histocrat/hello_world), 13 bytes, `1193`
```
hello, world!
```
[Answer]
# Ruby, sum 3373, 37 bytes
```
require'prime'
g=gets.to_i
p g.prime?
```
[Answer]
# Microscript II, 2 bytes (sum 137)
```
N;
```
# Microscript II, 4 bytes (sum 353)
```
N;ph
```
I'm actually quite surprised that both of these wound up having prime byte sums.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes, `173`
```
p=
```
Explanation:
```
p  # Checks if number is prime - returns 1 if true and 0 if false. Uses implicit input.
 = # Wouldn't usually be required for this sort of program, but I added it to make the sum prime.
```
[Try it online!](https://tio.run/nexus/05ab1e#@19g@/@/KQA)
[Answer]
# Pyth, 2 bytes, `127`
```
/P
```
[Try it online](https://pyth.herokuapp.com/?code=%2FP&input=127&debug=0)
Outputs `1` for primes, `0` for non-primes.
`/` has code point `47`. `P` has code point `80`.
How it works:
```
/P
/PQQ    Implicit variables.
        Q = input
 PQ     Prime factorize Q.
/  Q    Count how many times Q appears. 1 if prime, 0 if not.
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 1 byte, sum 23
```
æ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C3%A6&inputs=23&header=&footer=)
`æ` is the built-in primality checker. Vyxal uses its own codepage, in which the character `æ` is `0x17`, or `23`, which is a prime number.
[Answer]
# Excel, ~~34~~ 30 bytes, sum ~~2039~~ 1759
```
=SUM(--(MOD(A2,ROW(A:A))=0))=2
```
Uses `ROW` instead of `SEQUENCE` which makes it shorter. As a added bonus, it now uses functions available at the time the question was asked.
## Original Answer
```
=SUM(--(MOD(A2,SEQUENCE(A2))=0))=2
```
Uses `SEQUENCE` which was not available when the question was posted.
[Answer]
# Python 2, 50 bytes, `4201`
Works for 1. Output is positive if prime, or zero if not.
```
p=input();print all(p%m for m in range(2,p))*~-p;p
```
[**Try it online**](https://tio.run/##K6gsycjPM/r/v8A2M6@gtERD07qgKDOvRCExJ0ejQDVXIS2/SCFXITNPoSgxLz1Vw0inQFNTq063wLrg/38TIwNDAA)
---
# Python 2, 44 bytes, `3701`
Doesn't work for 1. Outputs a Boolean.
```
p=input();print all(p%k for k in range(2,p))
```
[**Try it online**](https://tio.run/##K6gsycjPM/r/v8A2M6@gtERD07qgKDOvRCExJ0ejQDVbIS2/SCFbITNPoSgxLz1Vw0inQFPz/39jcwNDAA)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 2 bytes, `191`
```
Uj
```
`U` :`85`
`j` : `106`
[Try it online!](https://tio.run/nexus/japt#@x@a9f@/MQA "Japt – TIO Nexus")
[Answer]
# Haskell, 52 bytes, 4421
```
main=do
 k<-readLn
 print$product[1..k-1]`rem`k==k-1
```
Wilson theorem.
[Answer]
# PHP, 38 bytes, sum 2791
Fun fact: With `$h` instead of `$c`, the sum would be `2801` (also a prime), and its binary representation `101011110001` read as decimal is also a prime number.
```
for($b=$c=$argv[1];$c%--$b;);echo$b<2;
```
takes command line argument, prints `1` or empty string. Run with `-r`.
Code taken from [my own prime function](https://stackoverflow.com/questions/38008130/php-check-if-number-is-prime/39743570#39743570) (look at the original post if you can).
[Answer]
# JavaScript (ES6), 40 bytes, `3203`
*Saved 6 bytes thanks to [@l4m2](https://codegolf.stackexchange.com/users/76323/l4m2)*
```
g=x=>m%--x?g(x):x<2;alert(g(m=prompt()))
```
[Try it online!](https://tio.run/##jY7NCsIwEITvPsVSEDbYLP7c1FTExxCRsA1RaZqQVsnbx1QvHr0O38w3D/3SA8d7GGXvW5N1Z@IICtj3g@8Mdd7OQvQuTOEVVAOrTbYqqcbNpUwHi0ls0369@xTRolNfHIUQ@WcFz0RU/dusLhRN@2SDGGpgMYkDLICJbzqeytNj4WpYFskb "JavaScript (Node.js) – Try It Online")
[Answer]
# R, 27 ~~32~~ bytes, sum 2243 ~~2609~~
Saved a 5 bytes thanks to @rturnbull
```
cat(gmp::isprime(scan(),r=43)>0)
```
This makes use of the gmp library's isprime function.
```
> sum(as.integer(charToRaw('cat(!!gmp::isprime(scan()))')))
[1] 2243
> cat(!!gmp::isprime(scan()))
1: 2243
2: 
Read 1 item
TRUE
> 
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/) + `dfns`, 7 bytes
## Sum: 569
```
1 pco⌈⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qc6SCekpaXrE616OO9rT/hgoFyfmPejqAMv@BAv850xS4DI2NzQE "APL (Dyalog Unicode) – Try It Online") or [Verify](https://tio.run/##SyzI0U2pTMzJT///qG@qc6SCekpaXrE616OO9rT/hgoFyfmPejqAMv@BAv850xS4DLhApCGYNAKTxmDSBCJuwsUFVP2obYK6OowRXJqrkJ@mkJyfklqQn5lXAjS9GCiurQ@U9/TXfdS7AshwDHvUu1kdyUKgIpgBnsUKAUWZuan26lxgBQrFAA "APL (Dyalog Unicode) – Try It Online")
The program uses the ceiling function(`⌈`) since it's a no-op on integers, and pads the codepoint sum to a prime number, according to APL's code page.
`pco` is a function from the dfns library which checks for primality.
[Answer]
# [Factor](https://factorcode.org/) + `math.primes`, sum 3373, 34 bytes
```
readln string>number prime? pprint
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQma@Qm1iSoVeQWFScWgRlF2XmphYrFBSllpRUAjl5JQrW/4tSE1Ny8hSKS4D8dLu80twkoHKwSnuFArCi//8NDQE "Factor – Try It Online")
Should be pretty self-explanatory I hope!
[Answer]
# Python 2, 44 bytes, byte-sum 3109
This is [xnor's 44 byte implementation](https://codegolf.stackexchange.com/a/58114/53748) with the lowest valued variable names that yield a prime byte sum.
Prints `1` if prime and `0` if not.
```
C=B=1
exec"B*=C*C;C+=1;"*~-input()
print B%C
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly) 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page), byte-sum 691
```
ƓÆḍ,ṠE
```
prints `1` if prime and `0` if not.
**[TryItOnline!](https://tio.run/nexus/jelly#@39s8uG2hzt6dR7uXOD6/78xAA)**
The bytes in hexadecimal are `93 0D D5 2C CD 45` (see the [code page](https://github.com/DennisMitchell/jelly/wiki/Code-page)), or in decimal are `147 13 213 44 205 69` which sum to 691, which is prime.
### How?
```
ƓÆḍ,ṠE - Main Link: no arguments
Ɠ      - read and evaluate a line from STDIN (integer expected)
 Æḍ    - proper divisor count
   ,   - paired with
    Ṡ  - sign
     E - all equal? - returns a boolean (1 or 0)
       - implicit print
```
The `Æḍ` functionality is such that primes and their negations return one while other integers do not (composites and their negations return numbers greater than one, one and minus one return zero and zero returns, oddly enough, minus one).
The `Ṡ` functionality is such that negative integers return minus one, zero returns zero and positive integers return one.
Thus the two functions only return the same value for the primes.
Note that the 3 byte program `ƓÆP` which directly tests if the input from STDIN is prime is unfortunately not a prime-sum program (240).
Testing for equality using `=`(equals), `e`(exists in), or `⁼`(non-vectorising equals) for 5 bytes also do not yield prime-sum programs.
---
# Alternative (maybe not acceptable) 4 bytes, sum 571
If the I/O restrictions still allow full programs that take an argument.
```
Æḍ⁼Ṡ
```
...using the same principle as above, where `⁼` is non-vectorising equality (the non-vectorising aspect has no effect since there is nothing to vectorise over anyway). The hex values are `0D D5 8C CD` which are `13 213 140 205` in decimal which sum to 571, a prime.
Again note that the 2 byte program `ÆP` does not have a prime sum (93).
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 4 bytes, byte-sum 439
```
qimp
```
Uses the built-in primality test.
[Try it online!](https://tio.run/nexus/cjam#@1@YmVvw/7@JsSUA "CJam – TIO Nexus")
### Alternate solution, 4 bytes, sum 461
```
r~mp
```
[Answer]
## Mathematica, 21 bytes, `1997`
```
Print@*PrimeQ@Input[]
```
`Input[]` reads a line of input (from STDIN if no front end is used, through a dialog box if the Mathematica front end is used), `Print@*PrimeQ` is the composition ([`@*`](http://reference.wolfram.com/language/ref/Composition.html)) of the `Print` and `PrimeQ` functions, and `@` is prefix function notation.
[Answer]
# [Perl 6](http://perl6.org/), ~~24~~ 22 bytes, `1949`
```
say .is-prime
for +get
```
All three whitespace characters are required.  
(Perl 6 doesn't care what *kind* of whitespace character they are, though, so I chose a newline instead of the more commonly used space for the second one...)
[Answer]
## Pyth, 4 bytes, `367`
```
}QPQ
```
[Try it here!](http://pyth.herokuapp.com/?code=%7DQPQ&input=367&debug=0)
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 8 bytes, `511`
```
0Na%,a=1
```
I wrote a prime checker, and the sum was prime. Convenient. Verify inputs 1-30: [Try it online!](https://tio.run/nexus/pip#@@@mkKgQo2NsoFDNFaCQqFesp8HFZeCXqKqTaGvIxaVZ@///fyNjAA "Pip – TIO Nexus")
### Explanation
```
          a is first command-line argument
    ,a    Numbers from 0 to a-1
  a%      Take a mod each of those numbers (a%0 gives nil)
0N        Count number of times 0 occurs in that list
      =1  If 0 occurs only 1 time (for a%1), then a is prime
```
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 23 bytes, `2111`
```
print(2>=numdiv(input))
```
[Try it online!](https://tio.run/##K0gsytRNL/j/v6AoM69Ew8jONq80NyWzTCMzr6C0RFPz/38jQ0NDAA "Pari/GP – Try It Online")
[Answer]
# J, 18 Bytes, `1103`
```
echo 1&p:".(1!:1)1
```
Not far from optimal, the least I could golf a full program primality test to was 17 Bytes: `echo(p:[:".1!:1)1`, which unfortunately sums to 1133 = 11\*103.
Unfortunately I can't figure out how to get keyboard input working on TIO, so no link yet.
### Explanation:
```
echo 1&p:".(1!:1)1  | Full program
           (1!:1)1  | Read a line of input from keyboard
         ".         | Evaluate (converts string to int)
     1&p:           | 1 for prime, 0 for composite
echo                | Print result. The space is required, as 'echo1' would be interpreted as a variable
```
Validating the program:
```
   1 p:+/u:inv'echo 1&p:".(1!:1)1'  NB. Convert to ints, sum, and test primality
1
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~62~~ 60 bytes, 4583
Pretty straight-forward. Outputs \* if prime, otherwise it outputs a space. Does not work for 1.
-2 thanks to [l4m2](https://codegolf.stackexchange.com/users/76323/l4m2)
```
p;main(i){for(scanf("%d",&p);++i<p;)p=p%i?p:0;puts("*"+!p);}
```
[Try it online!](https://tio.run/##S9ZNT07@/7/AOjcxM08jU7M6Lb9Iozg5MS9NQ0k1RUlHrUDTWls706bAWrPAtkA1077AysC6oLSkWENJS0lbEShb@/@/iamFMQA "C (gcc) – Try It Online")
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 36 bytes, byte-sum 2239
```
{for(a=1;$0%++a&&a<$0;);$0=(a==$0)}1
```
[Try it online!](https://tio.run/##SyzP/v@/Oi2/SCPR1tBaxUBVWztRTS3RRsXAWhPItQUK26oYaNYa/v9vyGXEZcJlymVoyGVoxGVozGVmwGVmyAUA "AWK – Try It Online")
Outputs `0` if not prime and `1` for prime.
Definitely not the most efficient code, since it checks every integer greater than `1` to see if it divides the input.
[Answer]
# [Whispers v2](https://github.com/cairdcoinheringaahing/Whispers), 33 bytes
```
>>> ⊤ℙ∘ℕ
> Input
>> 1∘2
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fzs5O4VHXkkctMx91zHjUMpXLTsEzr6C0hAsobggUAioxNAYA "Whispers v2 – Try It Online")
1. Score: `44381`
2. Only 6 bytes/2 characters added to make it valid!
3. **1** is not prime
## How it works
This is shown in the order it is executed in:
```
		; Line 3:
>>  ∘		; Compose...
   1            ; Line 1 with
     2          ; The result of line 2
		; Line 2:
> Input		; Retrieve a line of input
		; Line 1:
>>> ⊤		; The input is...
     ℙ		; Prime
      ∘		; And it is...
       ℕ	; Natural
```
[Answer]
# Excel (57 bytes, code sum 3547)
```
=XOR(0<PRODUCT(MOD(A1,ROW(OFFSET(D2,0,,SQRT(A1))))),3>A1)
```
Excel doesn't really have an "input" as such, but this formula expects the number to be tested to be in A1 and outputs to whatever cell you drop it in. It's an array formula, so press Ctrl-Shift-Enter to enter it, rather than Enter.
[Answer]
# TI-Basic, 27 bytes, byte-sum 2843
```
Prompt F
3
For(A,2,sqrt(F
If not(remainder(F,A
0
End
Disp Ans
```
Prints `3` for prime and `0` for composite. Does not work for 1 (prints `3`).
TI-Basic is a [tokenized lanugage](http://tibasicdev.wikidot.com/one-byte-tokens). `remainder(` is a two-byte token; all others are one-byte tokens.
Explanation:
```
Prompt F             # 0xdd, 0x46, 0x3f # Store input in F
3                    # 0x33, 0x3f       # Store 3 in Ans
For(A,2,sqrt(F       # 0xd3, 0x41, 0x2b, 0x32, 0x2b, 0xbc, 0x46, 0x3f
                        # For each integer A from 2 to sqrt(F)
If not(remainder(F,A # 0xce, 0xb8, (0xef, 0x32), 0x46, 0x2b, 0x41, 0x3f
0                    # 0x30, 0x3f
                        # If F is divisible by A, store 0 in Ans
End                  # 0xd4, 0x3f # end For loop
Disp Ans             # 0xde, 0x72 (no newline) # Print Ans
```
Sum testing with Python:
```
>>> sum(eval(i) for i in ['0xdd', '0x46', '0x3f', '0x33', '0x3f', '0xd3', '0x41', '0x2b', '0x32', '0x2b', '0xbc', '0x46', '0x3f', '0xce', '0xb8', '0xef', '0x32', '0x46', '0x2b', '0x41', '0x3f', '0x30', '0x3f', '0xd4', '0x3f', '0xde', '0x72'])
2843
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes, [Σ](https://github.com/DennisMitchell/jelly/wiki/Code-page) = 239
```
ÆPa1
```
[Try it online!](https://tio.run/##y0rNyan8//9wW0Ci4f///40A "Jelly – Try It Online")
Proof: [Try it online!](https://tio.run/##y0rNyan8///wDK/MwxMeNa151DAz@HBbwP///9WBVKKhOgA "Jelly – Try It Online") (take the 1-based indices of the program's chars of Jelly's code page, decrement to make them 0-based, sum and then check if the result is prime).
]