Un premier test qui est LITTÉRALEMENT premier

23

É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:

Afficher l'extrait de code

code-golf  math  restricted-source  primes 
— Noah L
source
12
Dans les langues autres que le golf, il semble que vous puissiez simplement prendre le code de décision premier le plus court et modifier les noms de variable jusqu'à ce que la somme soit première.
— xnor
5
Pourquoi les restrictions sur les E / S?
— Jonathan Allan
2
Qu'est-ce qu'une "valeur Unibyte"?! ???
— aditsu
5
Vous parlez de caractères et de pages de codes. Un caractère Unicode a toujours le même point de code, quel que soit l'encodage utilisé pour le représenter. Quant aux caractères non ASCII, ils doivent être affectés à la valeur dans leur codage respectif. me fait penser que vous voulez réellement que la somme des valeurs d' octets soit première
— Dennis
3
— Titus

Réponses:

6

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.

— SuperJedi224
source
4

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.
— isaacg
source
4

Haskell, 52 octets, 4421

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

Théorème de Wilson.

— fquarp
source
2
Transformé en un programme autonome complet.
— fquarp du
Le ne ::IO Intdevrait vraiment pas être nécessaire , à moins que c'est le chemin le plus court , vous pouvez obtenir une somme de premier choix.
— Ørjan Johansen
Bon appel. Cependant, nous obtenons ensuite du code qui «hache» une valeur paire. L'ajout d'espaces ou de nouvelles lignes ne fait rien (même des valeurs), pas plus que le changement du nom de la variable (il apparaît quatre fois, donc remplacer son code (disons c) revient à soustraire 4 * c et à ajouter 4 * c ', laissant le Cependant, il peut être modifié en brisant les lignes et être encore plus court, ce que j'ai fait.
— fquarp
1
47 octets avec un test de primalité différent: essayez-le en ligne! (notez qu'il y a des tabulations au lieu d'espaces pour obtenir le bon compte).
— Laikoni
Bienvenue également à PPCG!
— Laikoni
4

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

— mbomb007
source
3

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!

— Okx
source
Quelque chose quelque chose "les commentaires ne sont pas autorisés" mais je suppose que les no-op efficaces fonctionnent très bien: D
— Value Ink
2

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).

— Titus
source
@Artyer C'est fixe.
— Titus
2

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
>
— MickyT
source
cat(!!gmp::isprime(scan()))est 5 octets plus court, et somme à 2243, aussi premier.
— rturnbull
@rturnbull merci pour ça :)
— MickyT
1

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
— Jonathan Allan
source
1

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).

— Jonathan Allan
source
ƓÆPG(311) et ÆPF(163) devraient être bien, je pense?
— Lynn
En Unicode, pour ƓÆḍ,ṠE, la valeur est 16183, ce qui est par hasard premier!
— Artyer
@Lynn Oui, il semble que la "restriction de code inutile" (à l'exception du caractère espace) ait été levée, ce qui rend ƓÆPGOK. J'ai également demandé si un programme prenant des données plutôt que l'utilisation de STDIN est acceptable.
— Jonathan Allan
1
... Si ces deux choses sont OK, alors ÆP¥3 octets et 97.
— Jonathan Allan
1

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.

— ngenisis
source
1

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 ...)

— smls
source
1

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
— DLosc
source
1

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
— Bolce Bussiere
source
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!

— gastropner
source
1
n;main(i){for(scanf("%d",&n);++i<n;)n=n%i?n:0;puts("*"+!n);}peut avoir besoin de changer le nom d'une variable pour la somme principale
— l4m2
@ l4m2 Nice one!
— gastropner
1

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.

— Robert Benson
source
1

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.

— Sophia Lechner
source
1

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.

— Kevin Cruijssen
source
0

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.

— 12Me21
source
0

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

— dragonite44
source
0

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
— caird coinheringaahing
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.