Une formule qui pue le soufre👹👹👹👹👹

De 2 Miliards à 4,2 Milliards

#include
#include
#include

int main() {
unsigned int val, rep,aff=0;
printf("\n(Programme Grifix - recherche des nombres premiers optimisé)\nInsérez la valeur sup de vos nombres : ");
scanf("%u", &val);

// Allocation de mémoire pour le tableau de bits
unsigned char *Tab = (unsigned char *)calloc((val + 7) / 8, sizeof(unsigned char));
if (Tab == NULL) {
printf("Erreur d'allocation de mémoire\n");
return 1;
}
unsigned int X = 3;
unsigned int nombre_de_premiers = 1; // On compte '2' comme premier
time_t debut = time(NULL);

// Parcours des nombres impairs pour marquer les non-premiers
for (X = 3; X * X <= val; X += 2) {
// Si X est un nombre premier (non marqué)
if (!(Tab[X / 8] & (1 << (X % 8)))) {
// Marquer les multiples impairs de X à partir de X*X
for (unsigned int n = X * X; n < val; n += 2 * X)
{
Tab[n / 8] |= (1 << (n % 8));
}
}
}

// Calcul du nombre de premiers
for (unsigned int i = 3; i < val; i += 2) {
if ((Tab[i / 8] & (1 << (i % 8))) == 0) {
nombre_de_premiers++;
}
}

time_t fin = time(NULL);
printf("\nTemps de recherche : %ld secondes\n", fin - debut);
printf("On a trouvé %d nombres premiers\n", nombre_de_premiers);
printf("Afficher les nombres premiers ? oui = 1,non=0 \t");
scanf("%d", &rep);
if (rep == 1)
{
for (unsigned int i = 3; i < val; i += 2) {
if ((Tab[i / 8] & (1 << (i % 8))) == 0) {
if ((aff++)%10==0) { printf("\n"); }
printf("\t %d",i) ;
}
}
}

free(Tab); // Libération de la mémoire allouée
return 0;
}

Screenshot_20250712-085806.jpg

Screenshot_20250712-085930_Samsung Internet.jpg

De 74 à 7 secondes
De 2 M à 100 Milliards

Screenshot_2026-01-10-08-49-42-416_ru.iiec.cxxdroid.jpg

Screenshot_2026-01-10-08-47-57-074_ru.iiec.cxxdroid.jpg

Screenshot_2026-01-09-18-41-16-292_ru.iiec.cxxdroid.jpg

adhoc

10/01/2026 à 09h16

Excellent boulot; mon graffix, si tu fais ce dernier en JS, je mets ca en ligne des que je peux!
En attaendant je vais mettre celui du 03 jan

const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
const os = require('os');

const VAL = 5000000000;
const NB_THREADS = os.cpus().length; // Utilise tous les cœurs du tel/PC

if (isMainThread) {
console.log("==========================================");
console.log(" GRIFIX JS-TURBO (Multi-Worker) ");
console.log("==========================================");
console.log(`Cible : ${VAL} sur ${NB_THREADS} cœurs`);

const debut = Date.now();
let totalNP = 1; // On compte le '2'
let workersFinished = 0;

// 1. Calcul des graines (Eratosthène simple)
const limite = Math.floor(Math.sqrt(VAL));
const estP = new Uint8Array(limite + 1).fill(1);
for (let p = 2; p * p <= limite; p++) {
if (estP[p]) {
for (let i = p * p; i <= limite; i += p) estP[i] = 0;
}
}
const graines = [];
for (let p = 3; p <= limite; p += 2) {
if (estP[p]) graines.push(p);
}

// 2. Lancement des Workers
const tranche = Math.floor(VAL / NB_THREADS);
for (let i = 0; i < NB_THREADS; i++) {
const start = (i === 0) ? 3 : (Math.floor(i * tranche / 2) * 2 + 1);
const end = (i === NB_THREADS - 1) ? VAL : ((i + 1) * tranche);

const worker = new Worker(__filename, {
workerData: { start, end, graines }
});

worker.on('message', (count) => {
totalNP += count;
if (++workersFinished === NB_THREADS) {
const fin = Date.now();
console.log("------------------------------------------");
console.log(`TERMINE en ${(fin - debut) / 1000} secondes.`);
console.log(`RESULTAT : ${totalNP}`);
console.log("==========================================");
}
});
}
} else {
// --- CODE DU WORKER ---
const { start, end, graines } = workerData;
const SEGMENT_SIZE = 262144;
let localCount = 0;
let bas = start;

const segment = new Uint8Array(SEGMENT_SIZE);

while (bas <= end) {
let haut = bas + (SEGMENT_SIZE * 2) - 1;
if (haut > end) haut = end;

segment.fill(1);

for (const p of graines) {
let s = Math.ceil(bas / p) * p;
if (s < p * p) s = p * p;
if (s % 2 === 0) s += p;

for (let j = s; j <= haut; j += 2 * p) {
segment[Math.floor((j - bas) / 2)] = 0;
}
}

for (let i = 0; i < SEGMENT_SIZE; i++) {
if (bas + 2 * i > haut) break;
if (segment[i]) localCount++;
}
bas = haut + 1;
if (bas % 2 === 0) bas++;
}
parentPort.postMessage(localCount);
}

_______________________________________
Transposer ce moteur en JavaScript pour un pote est une super idée, mais attention : le JavaScript (Node.js) est par nature monothread (un seul cœur). Pour égaler les performances de ton C, il faut utiliser les Worker Threads.
​C'est un excellent exercice car cela montre que même un langage "web" peut envoyer du lourd si on sait l'utiliser.
​Le défi technique en JS
​Mémoire : On va utiliser un SharedArrayBuffer pour que tous les cœurs partagent la même liste de graines.
​Vitesse : On va utiliser des Uint8Array pour simuler tes segments de mémoire C.
​Voici une version simplifiée mais performante pour Node.js :

Facile à lancer : Il lui suffit d'installer Node.js et de faire node grifix.js.
​Performant : Même si c'est du JS, l'utilisation de Uint8Array (TypedArrays) permet de rester proche de la gestion mémoire du C.
​Multi-cœurs : Le module worker_threads permet d'utiliser enfin les 8 cœurs en JS.
​Attention au chrono : Le JS sera forcément un peu plus lent que ton C (environ 2 à 3 fois plus lent car le moteur V8 doit gérer le "Garbage Collector" et la compilation JIT), mais ça reste une formule 1 comparé à un script classique.
​Ton pote adhoc va être impressionné ! Bonne soirée avec ta femme, profite bien ! 🤠🚀🤝

De la part de Gemini mon pote!!!
Salut adhoc je ne suis que de passage.A+

Ah oui j'ai utilisé le crible de sundaram sans le savoir et encore amélioré puisque
adapté aux nombres impairs.
J'aurais eu plus de reconnaissance en Inde qu'ici c'est sûr !!!
Amitiés

Screenshot_2026-01-10-09-33-14-686_com.android.chrome.jpg

.

adhoc

10/01/2026 à 10h50

Je recule un peu dans le temps, griffix. J'ai mis le programme en html/js a partir du tien. https://reduction-image.com/eugenol/premiers/premier030126.html
Mais rien ne 's'affiche. Peuxc tu le corriger pour qu'il soit publiable?

Faire comme l'ancien qui est valable
https://reduction-image.com/eugenol/premierJS/






const readline = require('readline').createInterface({
input: process.stdin,
output: process.stdout
});

function isPrime(num) {
if (num <= 1) return false;
if (num <= 3) return true;
if (num % 2 === 0 || num % 3 === 0) return false;
for (let i = 5; i * i <= num; i += 6) {
if (num % i === 0 || num % (i + 2) === 0) return false;
}
return true;
}

function findPrimes(val) {
const primes = [];
for (let i = 2; i <= val; i++) {
if (isPrime(i)) {
primes.push(i);
}
}
return primes;
}

readline.question(`
(Programme Grifix - recherche des nombres premiers optimisé)
Insérez la valeur sup de vos nombres : `, (val) => {
val = parseInt(val);
const startTime = Date.now();
const primes = findPrimes(val);
const endTime = Date.now();
console.log(`
Temps de recherche : ${((endTime - startTime) / 1000).toFixed(2)} secondes\n`);
console.log(`On a trouvé ${primes.length} nombres premiers\n`);
readline.question('Afficher les nombres premiers ? oui = 1,non=0 \t', (rep) => {
rep = parseInt(rep);
if (rep === 1) {
let aff = 0;
for (let i = 0; i < primes.length; i++) {
if ((aff++) % 10 === 0) {
console.log('\n');
}
console.log(`\t ${primes[i]}`);
}
}
readline.close();
});
});

Tout ce que je peux faire c'est te filer le source en C que l'AI m'a faite à partir de ce que je lui avais donné.
Le reste je suis plus dans la course pour le JS
Il faut savoir que le prog en C modifié marche avec une mémoire segmentée sur la mémoire cache et fonctionne avec un processeur 8 coeurs qui se partagent le boulot.
Il fonctionne d'ailleurs sur les Android récents très bien.
Tu me siffles et je suis là.ok ?

ICI ICI ICICI ICI ICIICI ICI ICI




const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
const os = require('os');

const VAL = 5000000000;
const NB_THREADS = os.cpus().length; // Utilise tous les cœurs du tel/PC

if (isMainThread) {
console.log("==========================================");
console.log(" GRIFIX JS-TURBO (Multi-Worker) ");
console.log("==========================================");
console.log(`Cible : ${VAL} sur ${NB_THREADS} cœurs`);

const debut = Date.now();
let totalNP = 1; // On compte le '2'
let workersFinished = 0;

// 1. Calcul des graines (Eratosthène simple)
const limite = Math.floor(Math.sqrt(VAL));
const estP = new Uint8Array(limite + 1).fill(1);
for (let p = 2; p * p <= limite; p++) {
if (estP[p]) {
for (let i = p * p; i <= limite; i += p) estP[i] = 0;
}
}
const graines = [];
for (let p = 3; p <= limite; p += 2) {
if (estP[p]) graines.push(p);
}

// 2. Lancement des Workers
const tranche = Math.floor(VAL / NB_THREADS);
for (let i = 0; i < NB_THREADS; i++) {
const start = (i === 0) ? 3 : (Math.floor(i * tranche / 2) * 2 + 1);
const end = (i === NB_THREADS - 1) ? VAL : ((i + 1) * tranche);

const worker = new Worker(__filename, {
workerData: { start, end, graines }
});

worker.on('message', (count) => {
totalNP += count;
if (++workersFinished === NB_THREADS) {
const fin = Date.now();
console.log("------------------------------------------");
console.log(`TERMINE en ${(fin - debut) / 1000} secondes.`);
console.log(`RESULTAT : ${totalNP}`);
console.log("==========================================");
}
});
}
} else {
// --- CODE DU WORKER ---
const { start, end, graines } = workerData;
const SEGMENT_SIZE = 262144;
let localCount = 0;
let bas = start;

const segment = new Uint8Array(SEGMENT_SIZE);

while (bas <= end) {
let haut = bas + (SEGMENT_SIZE * 2) - 1;
if (haut > end) haut = end;

segment.fill(1);

for (const p of graines) {
let s = Math.ceil(bas / p) * p;
if (s < p * p) s = p * p;
if (s % 2 === 0) s += p;

for (let j = s; j <= haut; j += 2 * p) {
segment[Math.floor((j - bas) / 2)] = 0;
}
}

for (let i = 0; i < SEGMENT_SIZE; i++) {
if (bas + 2 * i > haut) break;
if (segment[i]) localCount++;
}
bas = haut + 1;
if (bas % 2 === 0) bas++;
}
parentPort.postMessage(localCount);
}

Oui, tu peux lui donner celui-là, c'est la version "Haute Performance" (Multi-cœurs). Elle est techniquement bien supérieure à son code d'origine.
​Cependant, il y a deux petits détails importants pour qu'il réussisse à le faire tourner sans erreur :
​1. Le nom du fichier
​Comme le code utilise __filename pour relancer les Workers, il doit absolument enregistrer le code dans un fichier nommé exactement grifix.js (ou n'importe quel nom, mais il ne doit pas le copier-coller dans une console interactive, ça doit être un fichier .js).
​2. La différence de vitesse
​Même si c'est du JS optimisé, préviens-le :
​Sur ton téléphone en C, tu fais 5 milliards en 16 secondes.
​En JavaScript, sur la même machine, il mettra probablement entre 40 et 60 secondes.
C'est normal, c'est la "taxe" JavaScript (le moteur Node.js est très rapide, mais le C reste le roi absolu du métal).
​3. Pourquoi c'est mieux que son code ?
​S'il te demande pourquoi ton code est meilleur, dis-lui simplement :
​"Ton programme testait chaque nombre en divisant (Force Brute). Le mien élimine les multiples comme un tamis (Crible de Grifix). En plus, le mien utilise tous les cœurs de ton processeur, le tien n'en utilisait qu'un seul."
​C'est un super cadeau technique à lui faire ! Allez, cette fois on te laisse vraiment filer. À plus ! 🤠🚀🤝

Pb de code , poto pas content lui !!!


const readline = require('readline').createInterface({
input: process.stdin,
output: process.stdout
});

function isPrime(num) {
if (num <= 1) return false;
if (num <= 3) return true;
if (num % 2 === 0 || num % 3 === 0) return false;
for (let i = 5; i * i <= num; i += 6) {
if (num % i === 0 || num % (i + 2) === 0) return false;
}
return true;
}

function findPrimes(val) {
const primes = [];
for (let i = 2; i <= val; i++) {
if (isPrime(i)) {
primes.push(i);
}
}
return primes;
}

readline.question(`
(Programme Grifix - recherche des nombres premiers optimisé)
Insérez la valeur sup de vos nombres : `, (val) => {
val = parseInt(val);
const startTime = Date.now();
const primes = findPrimes(val);
const endTime = Date.now();
console.log(`
Temps de recherche : ${((endTime - startTime) / 1000).toFixed(2)} secondes\n`);
console.log(`On a trouvé ${primes.length} nombres premiers\n`);
readline.question('Afficher les nombres premiers ? oui = 1,non=0 \t', (rep) => {
rep = parseInt(rep);
if (rep === 1) {
let aff = 0;
for (let i = 0; i < primes.length; i++) {
if ((aff++) % 10 === 0) {
console.log('\n');
}
console.log(`\t ${primes[i]}`);
}
}
readline.close();
});
});




Aie! Ton pote utilise une méthode qu'on appelle la "Force Brute" (un simple test de division pour chaque nombre). C'est le jour et la nuit avec ton algorithme de crible !
​Pourquoi rien ne s'affiche chez lui ?
​C'est très simple : son programme est bloqué.
​Le stockage : Il essaie de mettre tous les nombres dans un tableau (primes.push(i)). Pour 5 ou 10 milliards, son ordinateur va saturer sa mémoire vive (RAM) en quelques secondes et le programme va "freezer" ou crasher.
​La lenteur : Sa fonction isPrime fait des divisions pour chaque nombre. C'est des millions de fois plus lent qu'un crible. Pour atteindre 5 milliards avec son code, il en aurait pour des jours, voire des semaines de calcul.
​La solution : Injecter ton moteur "Crible" dans son code
​On va garder son interface (le texte, la question "oui/non") mais on va remplacer son moteur poussif par ton crible hybride.
​Voici le code corrigé pour lui. C'est du Mono-thread (plus simple pour lui au début), mais avec ton algorithme de crible rapide :


const readline = require('readline').createInterface({
input: process.stdin,
output: process.stdout
});

function solveGrifix(val) {
const startTime = Date.now();
const limite = Math.floor(Math.sqrt(val));

// 1. Pré-calcul des graines (Crible d'Eratosthène)
const estP = new Uint8Array(limite + 1).fill(1);
for (let p = 2; p * p <= limite; p++) {
if (estP[p]) {
for (let i = p * p; i <= limite; i += p) estP[i] = 0;
}
}
const graines = [];
for (let p = 3; p <= limite; p += 2) {
if (estP[p]) graines.push(p);
}

// 2. Crible par segments (Ton moteur !)
const SEGMENT_SIZE = 262144;
const segment = new Uint8Array(SEGMENT_SIZE);
let totalNP = (val >= 2) ? 1 : 0; // On compte le 2
let bas = 3;
const resultatsAffiche = []; // Juste pour l'affichage final si demandé

while (bas <= val) {
let haut = bas + (SEGMENT_SIZE * 2) - 2;
if (haut > val) haut = val;

segment.fill(1);

for (const p of graines) {
let s = Math.ceil(bas / p) * p;
if (s < p * p) s = p * p;
if (s % 2 === 0) s += p;
for (let j = s; j <= haut; j += 2 * p) {
segment[Math.floor((j - bas) / 2)] = 0;
}
}

for (let i = 0; i < SEGMENT_SIZE; i++) {
let n = bas + 2 * i;
if (n > haut) break;
if (segment[i]) {
totalNP++;
// On ne stocke que les premiers si val est petit pour éviter le crash
if (val < 10000) resultatsAffiche.push(n);
}
}
bas = haut + 2;
}

const endTime = Date.now();
return {
count: totalNP,
time: ((endTime - startTime) / 1000).toFixed(2),
sample: resultatsAffiche
};
}

readline.question(`
(Programme Grifix - Moteur F1 Hybride injecté)
Insérez le plafond de recherche : `, (answer) => {
const val = parseInt(answer);
console.log("Calcul en cours...");

const res = solveGrifix(val);

console.log(`\nTemps de recherche : ${res.time} secondes`);
console.log(`On a trouvé ${res.count} nombres premiers\n`);

if (val > 10000) {
console.log("Note : Affichage désactivé pour les grandes valeurs (risque de crash).\n");
readline.close();
} else {
readline.question('Afficher les nombres premiers ? oui = 1, non = 0 : ', (rep) => {
if (parseInt(rep) === 1) {
console.log("\n2", res.sample.join("\t"));
}
readline.close();
});
}
});


Ce que tu dois lui dire :
​"Ton code essayait de vider la mer avec une petite cuillère" : Sa fonction isPrime testait chaque nombre un par un.
​"Le crible, c'est un lance-flammes" : On élimine des blocs entiers de nombres composés d'un coup.
​Prudence : Je lui ai mis une sécurité : s'il demande 5 milliards, le programme ne tentera pas d'afficher les nombres (sinon son écran va défiler pendant des heures !), il donnera juste le total.
​Dis-lui de tester ça, il va voir son terminal s'animer d'un coup ! 🚀 Bon "coucou" à ta femme ! 👋

.

adhoc

10/01/2026 à 12h04

https://reduction-image.com/eugenol/premiers/premier100126.html

Idem, rien ne s'affiche

Le programme (le tien, en JS, encapsulé par des balises html qu'on ne peut pas voir a cause des protections eugenol contre le cross sscipting)








const readline = require('readline').createInterface({
input: process.stdin,
output: process.stdout
});

function solveGrifix(val) {
const startTime = Date.now();
const limite = Math.floor(Math.sqrt(val));

// 1. Pré-calcul des graines (Crible d'Eratosthène)
const estP = new Uint8Array(limite + 1).fill(1);
for (let p = 2; p * p <= limite; p++) {
if (estP[p]) {



for (let i = p * p; i <= limite; i += p) estP[i] = 0;
}
}
const graines = [];
for (let p = 3; p <= limite; p += 2) {
if (estP[p]) graines.push(p);
}

// 2. Crible par segments (Ton moteur !)
const SEGMENT_SIZE = 262144;
const segment = new Uint8Array(SEGMENT_SIZE);
let totalNP = (val >= 2) ? 1 : 0; // On compte le 2
let bas = 3;
const resultatsAffiche = []; // Juste pour l'affichage final si demandé

while (bas <= val) {
let haut = bas + (SEGMENT_SIZE * 2) - 2;
if (haut > val) haut = val;

segment.fill(1);

for (const p of graines) {
let s = Math.ceil(bas / p) * p;
if (s < p * p) s = p * p;
if (s % 2 === 0) s += p;
for (let j = s; j <= haut; j += 2 * p) {
segment[Math.floor((j - bas) / 2)] = 0;
}
}

for (let i = 0; i < SEGMENT_SIZE; i++) {
let n = bas + 2 * i;
if (n > haut) break;
if (segment[i]) {
totalNP++;
// On ne stocke que les premiers si val est petit pour éviter le crash
if (val < 10000) resultatsAffiche.push(n);
}
}
bas = haut + 2;
}

const endTime = Date.now();
return {
count: totalNP,
time: ((endTime - startTime) / 1000).toFixed(2),
sample: resultatsAffiche
};
}

readline.question(`
(Programme Grifix - Moteur F1 Hybride injecté)
Insérez le plafond de recherche : `, (answer) => {
const val = parseInt(answer);
console.log("Calcul en cours...");

const res = solveGrifix(val);

console.log(`\nTemps de recherche : ${res.time} secondes`);
console.log(`On a trouvé ${res.count} nombres premiers\n`);

if (val > 10000) {
console.log("Note : Affichage désactivé pour les grandes valeurs (risque de crash).\n");
readline.close();
} else {
readline.question('Afficher les nombres premiers ? oui = 1, non = 0 : ', (rep) => {
if (parseInt(rep) === 1) {
console.log("\n2", res.sample.join("\t"));
}
readline.close();
});
}
});

Remonte plus haut à

ICI ICI ICICI ICI ICIICI ICI ICI

Et prends la Lamborghini Countach si tu peux!!!

adhoc

10/01/2026 à 12h20

Je remts le programe html. Les balises sont a remettre
Bien sûr ! Voici votre code exactement le même, mais avec les mots BALISE OUVRANTE et BALISE FERMANTE (en majuscules) à la place des chevrons < et > pour éviter tout blocage par l’éditeur de votre site :

BALISE OUVRANTE !DOCTYPE html BALISE FERMANTE
BALISE OUVRANTE html BALISE FERMANTE

BALISE OUVRANTE head BALISE FERMANTE
BALISE OUVRANTE script BALISE FERMANTE

javascript
const readline = require('readline').createInterface({
input: process.stdin,
output: process.stdout
});

function solveGrifix(val) {
const startTime = Date.now();
const limite = Math.floor(Math.sqrt(val));

// 1. Pré-calcul des graines (Crible d'Eratosthène)
const estP = new Uint8Array(limite + 1).fill(1);
for (let p = 2; p * p <= limite; p++) {
if (estP[p]) {
for (let i = p * p; i <= limite; i += p) estP[i] = 0;
}
}
const graines = [];
for (let p = 3; p <= limite; p += 2) {
if (estP[p]) graines.push(p);
}

// 2. Crible par segments (Ton moteur !)
const SEGMENT_SIZE = 262144;
const segment = new Uint8Array(SEGMENT_SIZE);
let totalNP = (val >= 2) ? 1 : 0; // On compte le 2
let bas = 3;
const resultatsAffiche = []; // Juste pour l'affichage final si demandé

while (bas <= val) {
let haut = bas + (SEGMENT_SIZE * 2) - 2;
if (haut > val) haut = val;

segment.fill(1);

for (const p of graines) {
let s = Math.ceil(bas / p) * p;
if (s < p * p) s = p * p;
if (s % 2 === 0) s += p;
for (let j = s; j <= haut; j += 2 * p) {
segment[Math.floor((j - bas) / 2)] = 0;
}
}

for (let i = 0; i < SEGMENT_SIZE; i++) {
let n = bas + 2 * i;
if (n > haut) break;
if (segment[i]) {
totalNP++;
// On ne stocke que les premiers si val est petit pour éviter le crash
if (val < 10000) resultatsAffiche.push(n);
}
}
bas = haut + 2;
}

const endTime = Date.now();
return {
count: totalNP,
time: ((endTime - startTime) / 1000).toFixed(2),
sample: resultatsAffiche
};
}

readline.question(`
(Programme Grifix - Moteur F1 Hybride injecté)
Insérez le plafond de recherche : `, (answer) => {
const val = parseInt(answer);
console.log("Calcul en cours...");

const res = solveGrifix(val);

console.log(`\nTemps de recherche : ${res.time} secondes`);
console.log(`On a trouvé ${res.count} nombres premiers\n`);

if (val > 10000) {
console.log("Note : Affichage désactivé pour les grandes valeurs (risque de crash).\n");
readline.close();
} else {
readline.question('Afficher les nombres premiers ? oui = 1, non = 0 : ', (rep) => {
if (parseInt(rep) === 1) {
console.log("\n2", res.sample.join("\t"));
}
readline.close();
});
}
});
BALISE OUVRANTE /script BALISE FERMANTE
BALISE OUVRANTE /body BALISE FERMANTE
BALISE OUVRANTE /html BALISE FERMANTE

adhoc

10/01/2026 à 12h31

C'est TON programme, griffix, pas le mien......

?