Écrivez un programme qui testera la primauté d'un nombre spécifié et donnera la sortie sous forme de valeur booléenne (True est premier). Votre test principal peut (mais ne doit pas) être valable pour le numéro 1.

Voici le hic: votre programme lui-même doit totaliser un nombre premier. Convertissez chaque caractère (y compris les espaces) en sa valeur Unicode / ASCII ( table ). Ensuite, additionnez tous ces nombres pour obtenir la somme de votre programme.

Par exemple, prenez ce programme pas si génial que j'ai écrit en 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)

Si vous convertissez tous les caractères en leur valeur Unicode / ASCII correspondante, vous obtenez:

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 

Vous pouvez ensuite trouver la somme de ces nombres manuellement ou avec votre propre programme. Ce programme spécifique s'élève à 8293, ce qui est un nombre premier.

Bien sûr, c'est Code Golf, donc plus vous pouvez faire votre programme petit, mieux c'est. Comme l'ont souligné d'autres utilisateurs, ce programme n'est pas très golfique.

Quelques règles:

Les entrées valides incluent STDIN et les invites (pas de fonctions, c'est juste un moyen d'ajouter du code supplémentaire gratuit). Les espaces sont autorisés, mais uniquement s'ils sont essentiels à la fonctionnalité de votre programme. La sortie doit être une sortie, pas seulement stockée dans une variable ou retournée (utilisez print, STDOUT, etc.)

Les indicateurs peuvent être utilisés et doivent être comptés littéralement, et non développés. Les commentaires ne sont pas autorisés. Quant aux caractères non ASCII, ils doivent être affectés à la valeur dans leur codage respectif.

Assurez-vous d'indiquer la taille de votre programme et la somme du programme. Je vais tester pour m'assurer que les programmes sont valides.

Bonne chance!

Voici un extrait pour compter la somme de votre programme et vérifier s'il est premier:

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>

Bonjour le monde! , 13 octets,1193

hello, world!

Ruby, somme 3373, 37 octets

require'prime'
g=gets.to_i
p g.prime?

Microscript II, 2 octets (somme 137)

N;

Microscript II, 4 octets (somme 353)

N;ph

Je suis en fait assez surpris que ces deux aient fini par avoir des sommes d'octets.

Japt , 2 octets,191

Uj

U :85

j : 106

Essayez-le en ligne!

Pyth, 2 octets, 127

/P

Essayez-le en ligne

Sorties 1pour les nombres premiers, 0pour les non-nombres premiers.

/a un point de code 47. Pa un point de code 80.

Comment ça marche:

/P
/PQQ    Implicit variables.
        Q = input
 PQ     Prime factorize Q.
/  Q    Count how many times Q appears. 1 if prime, 0 if not.

Haskell, 52 octets, 4421

main=do
 k<-readLn
 print$product[1..k-1]`rem`k==k-1

Théorème de Wilson.

Python 2, 50 octets, 4201

Fonctionne pour 1. La sortie est positive si elle est première ou nulle sinon.

p=input();print all(p%m for m in range(2,p))*~-p;p

Essayez-le en ligne

Python 2, 44 octets, 3701

Ne fonctionne pas pour 1. Génère un booléen.

p=input();print all(p%k for k in range(2,p))

Essayez-le en ligne

JavaScript (ES6), 47 octets, 3541

Ceci est fortement basé sur la fonction de test de primalité ETHproductions , qui peut être trouvée ici .

alert((F=(n,x=n)=>n%--x?F(n,x):!~-x)(prompt()))

05AB1E , 2 octets,173

p=

Explication:

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.

Essayez-le en ligne!

PHP, 38 octets, somme 2791

Fait amusant: avec $hau lieu de $c, la somme serait 2801(également un nombre premier), et sa représentation binaire 101011110001lue comme décimale est également un nombre premier.

for($b=$c=$argv[1];$c%--$b;);echo$b<2;

prend l'argument de ligne de commande, imprime 1ou chaîne vide. Courez avec -r.

Code tiré de ma propre fonction principale (regardez le message d'origine si vous le pouvez).

R, 27 32 octets, somme 2243 2609

Enregistré 5 octets grâce à @rturnbull

cat(gmp::isprime(scan(),r=43)>0)

Cela utilise la fonction isprime de la bibliothèque gmp.

> sum(as.integer(charToRaw('cat(!!gmp::isprime(scan()))')))
[1] 2243
> cat(!!gmp::isprime(scan()))
1: 2243
2: 
Read 1 item
TRUE
> 

Python 2, 44 octets, somme des octets 3109

Il s'agit de l' implémentation de 44 octets de xnor avec les noms de variables de plus faible valeur qui produisent une somme d'octets premiers.

Imprime 1si premier et 0sinon.

C=B=1
exec"B*=C*C;C+=1;"*~-input()
print B%C

Gelée 6 octets , somme des octets 691

ƓÆḍ,ṠE

imprime 1si premier et 0sinon.

TryItOnline!

Les octets en hexadécimal sont 93 0D D5 2C CD 45(voir la page de codes ), ou en décimal sont la 147 13 213 44 205 69somme de 691, ce qui est premier.

Comment?

ƓÆḍ,Ṡ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

La Æḍfonctionnalité est telle que les nombres premiers et leurs négations renvoient un alors que les autres entiers ne le font pas (les composites et leurs négations renvoient des nombres supérieurs à un, un et moins un renvoient zéro et zéro renvoie, curieusement, moins un).

La Ṡfonctionnalité est telle que les entiers négatifs renvoient moins un, zéro renvoie zéro et les entiers positifs retournent un.

Ainsi, les deux fonctions ne renvoient que la même valeur pour les nombres premiers.

Notez que le programme à 3 octets ƓÆPqui teste directement si l'entrée de STDIN est premier n'est malheureusement pas un programme à somme prime (240).

Le test d'égalité à l'aide de =(égal), e(existe en) ou ⁼(non vectorisé égal) pour 5 octets ne donne pas non plus de programmes à somme prime.

Alternative (peut-être pas acceptable) 4 octets, somme 571

Si les restrictions d'E / S autorisent toujours des programmes complets qui prennent un argument.

Æḍ⁼Ṡ

... en utilisant le même principe que ci-dessus, où ⁼est l'égalité non vectorisante (l'aspect non vectorisant n'a aucun effet puisqu'il n'y a de toute façon rien à vectoriser). Les valeurs hexadécimales sont celles 0D D5 8C CDqui sont 13 213 140 205en décimales et totalisent 571, un nombre premier.

Notez à nouveau que le programme à 2 octets ÆPn'a pas de somme première (93).

CJam , 4 octets, somme des octets 439

qimp

Utilise le test de primalité intégré.

Essayez-le en ligne!

Solution alternative, 4 octets, somme 461

r~mp

Mathematica, 21 octets, 1997

Print@*PrimeQ@Input[]

Input[]lit une ligne d'entrée (à partir de STDIN si aucune extrémité avant est utilisée, par l' intermédiaire d' une boîte de dialogue si l'extrémité avant Mathematica est utilisé), Print@*PrimeQest la composition ( @*) du Printet les PrimeQfonctions, et @est fonction de notation de préfixe.

Perl 6 , 24 22 octets,1949

say .is-prime
for +get

Les trois caractères d'espacement sont requis.
(Perl 6 ne se soucie pas du type de caractère d'espaces, cependant, j'ai donc choisi une nouvelle ligne au lieu de l'espace le plus couramment utilisé pour la seconde ...)

Pyth, 4 octets, 367

}QPQ

Essayez-le ici!

Pip , 8 octets,511

0Na%,a=1

J'ai écrit un vérificateur principal, et la somme était première. Pratique. Vérifiez les entrées 1-30: essayez-le en ligne!

Explication

          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

Pari / GP , 23 octets,2111

print(2>=numdiv(input))

Essayez-le en ligne!

J, 18 octets, 1103

echo 1&p:".(1!:1)1

Non loin d'être optimal, le moins que j'ai pu jouer à un test de primalité de programme complet était de 17 octets:, echo(p:[:".1!:1)1ce qui correspond malheureusement à 1133 = 11 * 103.

Malheureusement, je ne sais pas comment faire en sorte que la saisie au clavier fonctionne sur TIO, donc pas de lien pour le moment.

Explication:

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

Validation du programme:

   1 p:+/u:inv'echo 1&p:".(1!:1)1'  NB. Convert to ints, sum, and test primality
1

C (gcc) , 62 60 octets, 4583

Assez simple. Sorties * si premier, sinon il sort un espace. Ne fonctionne pas pour 1.

-2 grâce à l4m2

p;main(i){for(scanf("%d",&p);++i<p;)p=p%i?p:0;puts("*"+!p);}

Essayez-le en ligne!

AWK , 36 octets, somme d'octets 2239

{for(a=1;$0%++a&&a<$0;);$0=(a==$0)}1

Essayez-le en ligne!

Sorties 0sinon amorces et 1pour amorces. Certainement pas le code le plus efficace, car il vérifie chaque entier supérieur à 1pour voir s'il divise l'entrée.

Excel (57 octets, somme de code 3547)

=XOR(0<PRODUCT(MOD(A1,ROW(OFFSET(D2,0,,SQRT(A1))))),3>A1)

Excel n'a pas vraiment une "entrée" en tant que telle, mais cette formule s'attend à ce que le nombre à tester soit en A1 et sort dans la cellule dans laquelle vous le déposez. C'est une formule matricielle, alors appuyez sur Ctrl-Maj-Entrée pour entrer plutôt que d'entrer.

Java 8, 114 octets, Prime 10037

interface M{static void main(String[]a){long n=new Long(a[0]),x=2;for(;x<n;n=n%x++<1?0:n);System.out.print(n>1);}}

Essayez-le en ligne.

Explication:

interface M{                     // Class
  static void main(String[]a){   //  Mandatory main-method
    long n=new Long(a[0]),       //   The first argument as number
    x=2;for(;x<n;n=n%x++<1?0:n); //   Check if `n` is a prime
    System.out.print(n>1);}}     //   Print whether `n` was a prime
                                 //    (if `n` is still the same: it's a prime;
                                 //     if `n` is now 0 or 1: it's not a prime)

J'ai utilisé xau lieu de ifaire de la somme unicode un nombre premier. Vérifiez ici la somme unicode.

Gelée , 4 octets, Σ = 239

ÆPa1

Essayez-le en ligne!

Preuve: essayez-le en ligne! (prendre les indices basés sur 1 des caractères du programme de la page de codes de Jelly, décrémenter pour les rendre basés sur 0, additionner puis vérifier si le résultat est premier).

SmileBASIC, 42 octets, 2687

INPUT N:FOR D=2TO N/2P=P+!(N MOD D)NEXT?!P

Affiche 1 (vrai) si le nombre est premier, sinon 0 (faux).

Les noms de variables n'ont pas seulement été choisis pour rendre le programme premier. Nest le n ombre de test, Dest le d iVisor, et Pconserve une trace du fait que N est p rime.

Wonder , 7 octets,537

pr rl e

Il y a probablement une meilleure façon ...

Rouille, 190 octets, 15013 partition

fn main(){let A=&mut"".into();std::io::stdin().read_line(A);let(B,mut C)=(A.trim().parse::<u64>().unwrap(),true);for H in 2..((B as f64).sqrt()+1.0) as u64{if B%H==0{C=false}}print!("{}",C)}

Non golfé

fn main() {
    let input = &mut "".into();
    std::io::stdin().read_line(input);
    let (number, mut prime) = (input.trim().parse::<u64>().unwrap(), true);

    for x in 2..((number as f64).sqrt() + 1.0) as u64 {
        if number % x == 0 {
            prime = false;
        }
    }

    print!("{}", prime);
}

Ne fonctionne pas pour 1

Stax , 349

|pq

Exécuter et déboguer

Whispers v2 , 33 octets

>>> ⊤ℙ∘ℕ
> Input
>> 1∘2

Essayez-le en ligne!

1. But: 44381
2. Seulement 6 octets / 2 caractères ajoutés pour le rendre valide!
3. 1 n'est pas premier

Comment ça marche

Ceci est indiqué dans l'ordre dans lequel il est exécuté:

		; 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