Bonjour,

Je viens vers vous car j'ai un problème. Je dois à l'aide de boucles et de fonctions récursives, énumérer les 2^n possibilités d'un nombre binaire de n bits. Mal heureusement je sèche un peu.

En gros je voudrais un fonction qui pour :

n = 1 ==> 0; 1

n = 2 ==> 00; 01; 10; 11

n = 3 ==> 000; 001; 010; 100; 011; 101; 110; 111

sauf que dans ma situation, j'ai un n = 15, soit plus de 32 000 possibilités.
Comment faire pour passer par tous les états possibles de mon chiffre à 15 bits.

Merci beaucoup de votre aide.

Salut, je te conseille de te renseigner vivement du côté des algorithmes de brute force et de backtrack. Pour la version récursive, tu peux voir toutes tes associations comme un arbre, il ne te reste plus qu'à parcourir cet arbre pour avoir toutes les possibilités.

Merci

beaucoup de ta réponse, je suis aller voir du côté des algo brut force, je m'y suis essayé, mais cela ne semble pas être concluent. Je me doute que mon erreur vient de l'imbrication de mes boucles, mais je n'arrive pas à trouver quoi.

Voici mon code:

function coverAllPosibilities(i){

	if (i == 0){
		group.layers[i].visible = false;
		saveJpeg(createName(group));
		group.layers[i].visible = true;
		saveJpeg(createName(group));
	}
	else{
		coverAllPosibilities(i - 1);

		for (var i = 14; i > 0; i--){
			for (var j = i - 1; j > 0; j--){

				for (var x = 0; x < 1; x ++){
					group.layers[i].visible = false;
					saveJpeg(createName(group));
					group.layers[i].visible = true;
					saveJpeg(createName(group));
				}

			}
		}

	}
}

Au final je n'ai que 27 possibilités qui ont été balayées, car 27 images sauvegardées.

Pour ton code, tu fais un mix de des deux bizarres, à quoi sert la ligne 10?

Pour tout ce qui est brute force, je te conseille vivement d'utiliser la version récursive des algorithmes qui sont plus courtes et claires à lire (après un peu d'entraînement).

Je te donne un petit indice pour la version récursive : le backtrack consiste à tester une valeur, puis revenir sur cette valeur pour la modifier. Par conséquent, ta fonction devrait se répartir sur un truc comme ça :

void bruteForce( tes paramètres, index){
  si index == -1{
    tu viens de trouver une feuille, tu fais ce que tu veux du traitement
  }
  valeur = false
  bruteForce(tes paramètres, index - 1)
  valeur = true
  bruteForce(tes paramètres, index -1)
}

Je suis rester un peu flou sur les paramètres et traitement car je ne sais pas ce que tu veux en faire, ni comment tu veux représenter ton nombre. Valeur correspond au bit que tu souhaites modifier. Index correspond à l'indice du bit (ou sa place dans le tableau si tu bosses avec des tableaux).

Je t'explique, en fait c'est pour un script photoshop. J'ai une image avec 15 calques différents.

Je doit générer et sauvegarder toutes les images possibles en fonction de ces 15 calques.
J'ai expliquer mon problème en parlant de binaire simplement car mes calques sont soit visibles, soit masqués.

Je te remercie de ta réponse, je vais étudier ça dans mon coin et te tiendrai au courant de mes avancées.
Merci beaucoup du temps que tu m'accordes

La ligne 10 servait à lancer la vérification des solutions à partir du ième bit, mais effectivement ce n'était pas une solution

-
Edité par PierrickGuguen 28 août 2019 à 12:49:31

Bon courage à toi.

N'hésite pas si tu rencontres d'autre problème. Juste par curiosité tu utilises quel langage pour faire des scripts photoshop?

C'est bon, j'ai réussi
Merci beaucoup

J'utilise du javascript, mais tu as aussi AppleScript et VBscript je crois.

Il existe des pdf des références de code pour photoshop, sur ce lien:
https://www.adobe.com/devnet/photoshop/scripting.html

Si tu veux voir le code globale, le voici.

// Initialisation
alert('Début du script');
group = app.activeDocument.layerSets.getByName('calques');

//reset de la visibilité
hideAll(group);

//Appel Main Fonction
coverAllPosibilities(14);

//FONCTIONS ----------------------------------------------
function coverAllPosibilities(i){

	if (i == 0){
		group.layers[i].visible = false;
		saveJpeg(createName(group));
		group.layers[i].visible = true;
		saveJpeg(createName(group));
	}
	else{		
		group.layers[i].visible = false;
		saveJpeg(createName(group));
		coverAllPosibilities(i - 1);

		group.layers[i].visible = true;
		saveJpeg(createName(group));
		coverAllPosibilities(i - 1);

	}
}

function hideAll(group){

	for (var i = 14; i >= 0; i--) {
		group.layers[i].visible = false;
	}
	//alert('hideAll OK');
}

function createName(group){
	var name = "";
	for (var i = 0; i <= 14; i++) {

		if(group.layers[i].visible == true){
			name = name + "_" + group.layers[i].name;
		}
		else{
			name = name + "_x";
		}
	}
	//alert('createName OK');
	return name;
}

function saveJpeg(name){
	var doc = app.activeDocument;
	var file = new File(doc.path + '/images/garden_MASK' + name + '.jpeg');

	var options = new JPEGSaveOptions();
	options.quality = 10;

	doc.saveAs(file, options, true);
	//alert('saveJpeg OK');
}

Et effectivement, la fonction récursive est si simple que j'ai du mal à me représenter comment avec ce peu de code j'arrive à balayer toutes les possibilités
Je m'imaginais avoir au moins 14 boucles (une par bit)

-
Edité par PierrickGuguen 28 août 2019 à 14:12:10

D'accord, j'aurai appris un truc.
Et oui c'est la magie du récursif, et l'avantage c'est que ton code marche pour autant de bit que tu veux (enfin presque^^)