JavaScript (ES6), 123 118 115 111 104 96 byte
Salvato 4 byte grazie a @Arnauld
G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>F(n-1,G(n,a=[0,0,n])||alert(n))
Una combinazione di tre tipiche funzioni ricorsive. Avvisa la sequenza in ordine inverso e termina con un errore "troppa ricorsione".
Test snippet
(modificato per l'output alla pagina)
alert = s => O.textContent += s + "\n"
G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>F(n-1,G(n,a=[0,0,n])||alert(n))
F(1000)
<pre id=O></pre>
La funzione principale può restituire un array per 104 byte:
G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>n?F(n-1).concat(G(n,a=[0,0,n])?[]:n):[]
Può anche essere non ricorsivo al costo di un altro byte:
G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
n=>[for(_ of Array(n))if(!G(--n,a=[0,0,n]))n]
Ecco quello con cui ho iniziato: (6 byte salvati grazie a @Arnauld)
P=(n,x=n)=>n>1&--x<2||n%x&&P(n,x)
G=n=>n?G(n>>1,o+=n%2,t++):P(o)&P(t-o)
F=n=>n?F(n-1).concat(P(n)&G(n,o=t=0)?n:[]):[]
Ho provato ulteriormente a giocare a golf e sono riuscito a farlo in 104 byte, poi ho capito che avevo già trovato quella soluzione (è in fondo alla risposta). Non lo odi quando succede? : P
Un tentativo non ricorsivo della funzione principale (di nuovo, stesso conteggio byte):
n=>[for(i of Array(n))if(P(--n)&G(n,o=t=0))n]
Questo prende la via facile per contare quanti 0 e 1 ci sono nella rappresentazione binaria:
F=n=>n?F(n-1).concat([n,(G=x=>n.toString(2).split(x).length-1)(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]
Stessa cosa con una comprensione dell'array:
n=>[for(_ of Array(n))if(![--n,(G=x=>n.toString(2).split(x).length-1)(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1))n]
Questo prende un percorso leggermente più difficile per fare la stessa cosa:
F=n=>n?F(n-1).concat([n,(G=(x,w=n)=>w&&G(x,w>>1)+(w%2==x))(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]
E questo prende ancora un altro percorso correlato che è breve come l'originale:
F=n=>n?F(n-1).concat([n,o=(G=x=>x&&x%2+G(n>>++t))(n,t=0),t-o].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]
Ancora una volta, puoi giocare a golf a 8 byte facendone allertare la sequenza in ordine inverso:
F=n=>F(n-1,[n,o=(G=x=>x&&x%2+G(n>>++t))(n,t=0),t-o].some(n=>(P=x=>n%--x?P(x):x)(n)-1)||alert(n))