La solution évidente serait de simplement les imprimer sous forme de chaîne, mais est-il possible d'écrire un code plus court?

Exigences:

1. Aucune entrée ne doit être traitée et la sortie doit être sous la forme 2 3 5 7 11 13 ...etc.
2. Aucun mot réservé dans la langue n'est utilisé du tout
3. Le langage devrait au moins permettre une programmation structurée et avoir des mots réservés (sinon le point 2 serait théorique).

_{J'ai d'abord pensé exclusivement au C / C ++, mais j'ai étendu la question tout en essayant d'empêcher la tricherie}

C, 60 caractères

La limitation "pas de mots clés" n'a pas d'importance ici. Je suis à peu près sûr que l'amélioration, si possible, ne se fera pas en ajoutant des mots clés.

n=2;main(m){n<720&&main(m<2?printf("%d ",n),n:n%m?m-1:n++);}

Version alternative:
La sortie n'est pas aussi agréable, mais j'aime l' printfabus.

n=2;main(m){n<720&&main(m<2?printf("%*d",n,n):n%m?m-1:n++);}

L'astuce dans les deux solutions est de fusionner deux boucles (implémentées par récursivité) en une seule.
nest le prochain potentiel premier, mle prochain diviseur potentiel.
Dans chaque appel récursif, nous incrémentons n(tout en définissant msa valeur précédente) ou décrémentons m.

Python, 108 caractères

Python n'était pas fait pour ce défi. Tu veux print? C'est réservé. Eh bien, que diriez-vous que nous utilisons stdout? Eh bien, ça va coûter unimport ... vous l'avez deviné, réservé. Eh bien ... je suis sur unix, donc je peux ouvrir le descripteur de fichier 1, qui se trouve être stdout. Pirater!

Homme, et itération? Rien que eval. Pas de boucles, bien sûr, mais nous ne pouvons même pas définir une fonction avec defou lambda. Et pour ajouter l'insulte à la blessure, nous ne pouvons même pas utiliser la compréhension de la liste! Je cherche toujours une excuse pour utiliser des choses comme map(p.__mod__,...)dans le golf de code ... la compréhension est toujours meilleure. Jusqu'à présent, c'est.

p=1
eval(compile("p+=1;open('/dev/fd/1','w').write('%s '%p*all(map(p.__mod__,range(2,p))));"*720,'','exec'))

Maintenant, vous pourriez plaignez execest un mot clé, même si je n'ai pas utilisé le mot - clé (je ne l' ai pas même evalun exec). Eh bien, voici une solution de 117 caractères qui n'utilise pas 'exec'.

p=2
s="eval('('+s*(p<720)+')',open('/dev/fd/1','w').write('%s '%p*all(map(p.__mod__,range(2,p)))),{'p':p+1})";eval(s)

JavaScript (80 caractères)

eval((s=Array(719)).join("s[j=++n]?j:"+s.join("s[j+=n]=")+"r+=n+' ';"),r="",n=1)

Exécutez dans la console de votre navigateur Web.

Utilisé un tamis primaire, qui s'est avéré être très condensé.

C, 183 caractères

#define q j*j<k?i%p[j++]||(i++,j=0):printf("%d\n",p[j=0,k++]=i++)
#define A q;q;q;q;q;q;q;q
#define B A;A;A;A;A;A;A;A
#define C B;B;B;B;B;B;B
main(){int i=2,j=0,k=0,p[999];C;C;C;C;C;}

Eh bien, voici une première tentative rapide. Je pense que cela devrait satisfaire aux exigences. J'utilise une division d'essai simple pour trouver les nombres premiers et une boucle déroulée construite à l'aide du préprocesseur pour l'itérer jusqu'à ce que j'en trouve suffisamment. Le nombre de répétitions a été modifié pour que 128 nombres premiers soient imprimés.

C, 87 caractères

d;p(n){--d<2||n%d&&p(n);}r(n){p(d=n);d<2&&printf("%d\n",n);++n<720&&r(n);}main(){r(2);}

(J'ai essayé de l'écrire dans un style plus fonctionnel, mais mon incapacité à utiliser a en returnquelque sorte tué ce plan.)

C, 134 caractères

Voici une solution alternative qui essaie d'éviter d'utiliser autant que possible des mots, réservés ou non:

main(i){i<9?main(2953216):i>4097?--i&4094?i/4096%(i%4096)?main(i):
main((i/4096-1)*4097):printf("%d\n",i>>12,main((i/4096-1)*4097)):0;}

Tout ce qu'il utilise est printfet mainavec un seul argument.

Mathematica 50 caractères

Je ne sais pas comment interpréter les "mots réservés" pour Mathematica, mais je veux jouer, donc je suppose que cela signifie se passer de fonctions intégrées pour générer des nombres premiers ou tester la primalité.

Fold[#2Cases[#/#2,1|_Rational]&,#,#]&@Range[2,719]

Haskell, 72 caractères

main=putStrLn.unwords$take 128[show p|p<-[2..],all((>0).mod p)[2..p-1]]

Certes, éviter les mots clés n'est pas trop difficile dans Haskell.

K (ngn / k) , 31 octets

x,1_&&/720#'!'x:24\234925135391

Essayez-le en ligne!