A solução óbvia seria imprimi-los apenas como uma string, mas é possível escrever um código mais curto?

Requisitos:

1. Nenhuma entrada deve ser processada e a saída deve estar na forma de 2 3 5 7 11 13 ...etc.
2. Nenhuma palavra reservada no idioma é usada
3. A linguagem deve pelo menos permitir programação estruturada e ter palavras reservadas (caso contrário, o ponto 2 seria discutível).

_{primeiro, eu tinha exclusivamente em mente C / C ++, mas estendi a pergunta enquanto tentava evitar trapaças}

C, 60 caracteres

A limitação "sem palavras-chave" não importa aqui. Tenho certeza de que melhorá-lo, se possível, não será feito adicionando palavras-chave.

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

Versão alternativa:
a saída não é tão boa, mas eu gosto do printfabuso.

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

O truque em ambas as soluções é mesclar dois loops (implementados por recursão) em um.
né o próximo primo em potencial, mo próximo divisor em potencial.
Em cada chamada recursiva, incrementamos n(enquanto definimos mseu valor anterior) ou diminuímos m.

Python, 108 caracteres

Python não foi criado para esse desafio. Quer print? Isso é reservado. Bem, que tal usarmos stdout? Bem, isso vai custar um import... você adivinhou, reservado. Bem ... eu estou no unix, então posso abrir o descritor de arquivo 1, que é stdout. Hack!

Cara, e iteração? Nada além disso eval. Sem loops, é claro, mas não podemos nem definir uma função com defou lambda. E para adicionar insulto à lesão, não podemos nem usar a compreensão da lista! Eu sempre procuro uma desculpa para usar coisas como map(p.__mod__,...)no código golf ... a compreensão é sempre melhor. Até agora, é isso.

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

Agora, você pode reclamar que execé uma palavra-chave, mesmo que eu não tenha usado a palavra-chave (eu nem usei evaluma exec). Bem, aqui está uma solução de 117 caracteres que não usa '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 caracteres)

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

Execute no console do seu navegador da web.

Usou uma peneira primária, que acabou sendo muito condensada.

C, 183 caracteres

#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;}

Bem, aqui está uma primeira tentativa rápida. Eu acredito que isso deve satisfazer os requisitos. Estou usando a divisão de teste simples para encontrar os primos e um loop desenrolado construído usando o pré-processador para iterá-lo até encontrar o suficiente deles. O número de repetições foi ajustado para que exatamente 128 números primos sejam impressos.

C, 87 caracteres

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);}

(Tentei escrever em um estilo mais funcional, mas minha incapacidade de usar returnmeio que acabou com esse plano.)

C, 134 caracteres

Aqui está uma solução alternativa que tenta evitar o uso de palavras, tanto quanto possível, reservada ou não:

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;}

Tudo o que ele usa é printfe maincom um único argumento.

Mathematica 50 caracteres

Não tenho certeza de como interpretar "palavras reservadas" para o Mathematica, mas quero jogar, então entendo que isso significa passar sem funções internas para gerar números primos ou testar a primalidade.

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

Haskell, 72 caracteres

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

É certo que evitar palavras-chave não é muito difícil em Haskell.

K (ngn / k) , 31 bytes

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

Experimente online!