Discussion :

[valentin03]

Re bonjour, quelqu'un pourrait-il me traduire en français les lignes commençant par trois points d'interrogation; ou que font concrètement ces lignes.
D'avance merci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
def permuter(chaine):
 
???    liste=[chaine[0]]
 
    n=2
    l=1
 
    while n <=len(chaine):
 
???        for mot in list(liste):
 
???            for i in range(n):
 
???                  liste.append(mot[:i]+chaine[l]+mot[i:])
 
        n+=1
        l+=1
 
 
???    return [r for r in liste if len(r)==len(chaine)]

[xdelatour]

C'est un extrait du manuscrit de Voynich ?

Plus sérieusement si "chaine" est une chaîne de caractères (ce que laisse supposer le "len(chaine)"), alors "chaine[0]" ne pourra jamais renvoyer une liste dont on pourrait extraire des mots.

À moins que la liste ne soit créée au fur et à mesure. Du genre : permuter("bonjour") va créer une liste contenant b, ob, nob, jnob, ojnob, uojnob et ruojnob. Ce qui expliquerait pourquoi on ne renvoie que l'élément de la liste qui a la même longueur que la chaîne du début. Mais ce n'est même pas sûr que ce soit ça.

Il n'y aurait pas plus compliqué ?

[valentin03]

Il n'y aurait pas plus compliqué ?

En voici un autre qui est plus ou moins sensé faire la même chose:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
def anagrammes(chaine, i):
???    liste = [chaine]
???    mot = chaine
???    for ii  in range(i, -1, -1):  
???        mot = mot[:ii] + mot[ii + 1] + mot[ii] + mot[ii + 2:]
???        liste.append(mot)
    i += 1
    if i < len(chaine) - 1:
???        for mot in list(liste):
???            liste +=  anagrammes(mot, i)
 
    return liste
 
anagrammes("iles", 0)

[xdelatour]

Déja, dans le premier code, la fonction range() prend un seul paramètre. Or, il y en a trois dans le second code.

Le but est de deviner ce que ça fait ou d'utiliser ce charabia pour écrire quelque chose de fonctionnel dans un langage précis ?

S'il s'agit de seulement traduire en français les mots-clés qui sont en anglais ça va être simple :

• for = pour chaque valeur de
• in=dans
• append=ajouter
• list=liste
• return=renvoyer
• len=longueur
• while=tant que

Et on pourra constater que ça n'a toujours pas de sens même en français.

Par exemple dans le premier code, il y a une boucle ligne 10 "pour chaque mot de la liste liste". Cette boucle est imbriquée dans une autre boucle qui est répétée autant de fois qu'il y a de caractères dans chaine, sachant qu'en plus on commence cette boucle avec la valeur 2

Rien que pour comprendre ça, ça me donne mal au crâne, mais en plus la liste est modifiée (ajout ligne 14) à l'intérieur de la boucle qui dépend des mots composant la liste (celle de la ligne 10)

[Flodelarab]

Bonjour

Déja, dans le premier code, la fonction range() prend un seul paramètre. Or, il y en a trois dans le second code.

Ce n'est pas impossible.
Si ce code est en langage python, alors range renvoie une liste. Tu peux indiquer le point d'arrivée et il partira de zéro, de 1 en 1. Sinon, tu peux indiquer le point de départ, le point d'arrivée et l'incrément. (3 paramètres).
Quand à Valentin03, on ne peut pas lire des tutoriels python à sa place. Il lui suffit de lire. Ne t'épuise pas à traduire.

[valentin03]

En fait, ce que je voudrais, c'est un algo EN PSEUDO CODE (c'est à dire en langage "commun" compréhensible par un enfant de 7 ans parlant couramment le français.) qui donne toutes les combinaisons d'une chaine de caractère de longueur n. (avec ou sans doublons,; en passant par des tableaux ou pas)
Parce que ça fait un bon moment que je m'explose le cerveau sur des syntaxes à dormir debout; toutes plus absconses les unes que les autres.

EDIT: @: xdelatour: Traduire en français La ligne: while n <=len(chaine)
Donne en français: Tant que n est plus petit ou égal à la longueur de la chaine "chaine", faire ce qui suit.
Et ce que fait concrètement la ligne,: C'est une boucle qui exécute le charabia qui suit.
Traduire mot à mot comme tu le fais ça s'appelle en français: Prendre les gens pour des cons.

[Nebulix]

La plus grosse difficulté en informatique, amha, est de savoir exactement ce qu'on veut faire. Il y a déjà un gros progrès entre le dernier post et le premier. "Toutes les combinaisons d'une chaine" n'est pas encore assez précis. En général, quand la description est assez précise, le codage s'ensuit sans difficulté.
Bon courage

[valentin03]

Je ne vois pas trop comment être plus précis que "toutes les combinaisons des caractères d'une chaine de longueur n"
Pour l'instant, j'en suis à faire des shuffles aléatoires de la chaine en boucle en éliminant les doublons au fur et à mesure, t'imagine pas le temps que ça prend.

[xdelatour]

Traduire mot à mot comme tu le fais ça s'appelle en français: Prendre les gens pour des cons.

Certaines personnes n'ont AUCUNE notion d'anglais et ne peuvent donc pas comprendre la moindre ligne de code dont les mots-clés sont en anglais.

quelqu'un pourrait-il me traduire en français

J'avais dû mal comprendre la question, désolé.

[xdelatour]

Je pense que ce que tu cherches à faire a un rapport avec la notion de permutation. Je ne suis pas assez calé en stats pour trouver la solution.

[tbc92]

Voici un code complet qui fonctionne. A adapter suivant les langages.
Je pense qu'avec des langages comme Python, on peut faire beaucoup plus court, et beaucoup plus rapide.

Déclaratives générales :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Scenario est une Structure
	sChaine_a_vider est une chaîne
	sChaine_a_remplir est une chaîne
FIN
tb_scenario est un tableau de 0 Scenario

Procédure principale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Scenar est un Scenario
t, n est un entier 
 
Scenar.sChaine_a_vider = "ABCDEFG"
Scenar.sChaine_a_remplir = ""          
TableauAjouteLigne(tb_scenario, Scenar)
 
n = TableauOccurrence(tb_scenario)
TANTQUE  n>0
	Scenar = tb_scenario[n]
	TableauSupprime(tb_scenario, n)
	t= Taille(Scenar.sChaine_a_vider)
	SI t = 0 ALORS 
		Trace (Scenar.sChaine_a_remplir)  	// Afficher Scenar.sChaine_a_remplir   .... On pourrait aussi écrire cette chaine dans un fichier
	SINON
		avance_une_lettre( Scenar)			// A partir du scenario en cours, recenser tous les scenarios suivants  	
	FIN
	n = TableauOccurrence(tb_scenario)
FIN

Procédure 'avance_une_lettre' :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
PROCEDURE avance_une_lettre(old_Scenar est un Scenario)
// Exemple 
//   Imaginons qu'en entrée on ait la structure {'ABC','DEFGH'}
//       C'est à dire qu'on a ABC dans Chaine_a_remplir et DEFGH dans chaine_a_vider.
//   Cette procédure va recenser 5 nouveaux scenarios. Elle va ajouter dans TB_SCENARIO les 5 scenarios suivants :
//    {'ABCD','EFGH'}  {'ABCD','DFGH'}  {'ABCF','DEGH'}  {'ABCG','DEFH'}  {'ABCH','DEFG'}
// Dans TB_scenario, on a donc supprimé 1 scénario ( commande TableauSupprime de la procédure principale) , et on l'a remplacé par 5 scenarios un peu plus avancés.
// -----------------------------------------------------------------------------------------------------------------------------------------------------------------
 
New_Scenar est un Scenario
i, n est un entier
n = Taille ( old_Scenar.sChaine_a_vider)
POUR i = 1 A n
	New_Scenar.sChaine_a_remplir = old_Scenar.sChaine_a_remplir + old_Scenar.sChaine_a_vider[[i]]
	New_Scenar.sChaine_a_vider = old_Scenar.sChaine_a_vider [[ 1 A i-1]] + old_Scenar.sChaine_a_vider[[i+1 A ]]
	TableauAjouteLigne(tb_scenario, New_Scenar)
FIN

Si la chaine d'entrée est "ABCDEF", en sortie, on aura les 720 arrangements possibles.
Si la chaine d'entrée est "ABCDEA", en sortie, on aura aussi 720 lignes, avec un certain nombre de doublons. Recenser les 720 lignes, puis éliminer les doublons, ça parait raisonnable.
Si par contre les chaines d'entrée sont du type "AAAAABBBBCCCDD", avec donc plein de doublons, recenser toutes les possibilités ( ici fact(14) possibilités, c'est à dire près de 100 milliards), puis ensuite dédoublonner, ce n'est pas raisonnable. Si la chaine d'entrée contient plein de doublons, il faut être un peu plus pointu.

[valentin03]

Merci beaucoup tbc92; je vais bûcher ce que tu donne (qui contient quand même pas mal d'abstractions et qui ressemble plus à une syntaxe de langage qu'à du pseudo code)
Les explications jointes vont aider (j'espère) à transcrire en clair.
Je vais finir par penser que les langages informatiques sont une corruption de l'esprit.

[Nebulix]

Je ne vois pas trop comment être plus précis que "toutes les combinaisons des caractères d'une chaine de longueur n"
Pour l'instant, j'en suis à faire des shuffles aléatoires de la chaine en boucle en éliminant les doublons au fur et à mesure, t'imagine pas le temps que ça prend.

Voilà qui est mieux.
Tu cherches donc toutes les permutations possibles de n caractères.
Tu peux choisir le premier parmi les n
Le 2e parmi les n-1 restant, etc soit n! (factorielle n)
La récursivité, peut être ...

[valentin03]

@: tbc92:
Bon voici ce que je crois comprendre:
- on met la chaine initiale dans un tableau [tb_scénario] (en position 1)
- n est la longueur de [tb_scénario]
- Tant que n >0
- On transfère la chaine n du tableau [tb_scénario] dans une chaine ("scenar") (qui n'apparaît plus nulle part sous ce nom ?!) (je présume que c'est new-chaine_remplir)
- On supprime la chaine n du tableau [tb_scénario]
- t = longueur chaine_initiale
- Si t = 0 (je présume qu'on passe)
- On fait old_chaine_vider = chaine_initiale (ça n'est pas précisé)
- Sinon:-->fonction(avance) ci dessous
- n = longueur chaine initiale
- Pour i = 1 à n
- new_chaine_remplir = old-chaine_remplir + old_chaine_vider (caractères un par un ("i")
- new_chaine_vider = old_chaine_vider (de 1 à i-1)
- on ajoute en "n" du tableau [tb_scenario] la new_scenar
(la "new_remplir" je suppose)
n=n+1
Bouclage
J'ai bon ?

[tbc92]

Les langages informatiques ne sont pas une corruption de l'esprit. Ce sont des langages qui permettent de dire très précisément ce qu'on veut. Ils permettent d'être très précis, mais ils exigent aussi d'être très précis.

Dans la langue parlée, si tu dis un truc et si ton interlocuteur comprend 50% de ce que tu lui dis, ça peut suffire, ce n'est pas catastrophique. En informatique, tu parles à un compilateur. Et il a besoin que tu lui donnes des ordres très précis. Si tu lui dis 'Débrouille-toi, essaie de comprendre', il ne va rien se passer.

Le code que j'ai posté, c'est effectivement du vrai code (langage Windev, mon chouchou).

On peut simuler chacune des étapes du programme :
- Va chez le libraire du coin, et achète un bloc-notes, avec plein de petites feuilles, ou achète 2 ou 3 paquets de post-it.
- tu prends également une boite type boite à chaussure. Cette boite , on l'appelle TB_SCENARIO.
- tu prends également une grande feuille de papier, sur laquelle tu écriras les solutions quand tu en auras. cette feuille de papier, on va l'appeler RESULTAT.

- tu prends un post-it et tu écris dessus ABCDEF en rouge, et rien en bleu. Et tu mets ce post-it dans la boite TB_Scenario ; C'est ce qui est fait dans les lignes 4.5.6 de ma procédure principale.

- Puis tu vas répéter les instructions ci-dessous autant de fois que nécessaires, tant qu'il y a au moins un post-it dans cette boite TB_SCENARIO :
- prendre le dernier post-it, celui qui a été mis dans la boite en dernier. Ce post-it, je vais l'appeler old_scenario. Le fait de prendre systématiquement le dernier post-it, ça permet d'avoir en permanence assez peu de post-it dans cette boite. Si tu prends à chaque fois le post-it qui a été mis en premier, au bout d'un moment, tu auras énormément de post-it dans cette boite.
- sur ce post-it old_scenario, tu lis ce qu'il y a en rouge et ce qu'il y a en bleu. Le premier post-it que tu vas prendre, il va avoir ABCDEF en rouge, et rien en bleu. Mais par la suite, tu auras autre chose bien sûr.

- S'il n'y a aucune lettre en rouge, il y a forcément 6 lettres en bleu. Ce post-it contient une nouvelle permutation des 6 lettres d'origine. Tu recopies donc le texte bleu de ce post-it sur la feuille resultat. Et tu peux mettre le post-it à la poubelle.
- S'il y a au moins une lettre en rouge, tu fais les opérations ci-dessous :
- Tu comptes le nombre de lettres en rouge (6 dans mon exemple).
- Tu prends donc 6 post-it vierges, et tu fais des 'vases communiquants' : tu déplaces une des lettres qui étaient en rouge dans le post-it original, et tu la mets en bleu dans le nouveau post-it. S'il y avait déjà du texte en bleu dans le post-it 'OLD_SCENARIO', tu rajoutes la nouvelle lettre à la fin du mot en bleu. Donc ici, tu vas avoir six post-it avec les contenus suivants : {A en bleu, BCDEF en rouge} , {B en bleu, ACDEF en rouge} ... etc.
Autre exemple, si le post-it que tu lis contient {BACD en bleu et EF en rouge}, tu prends 2 post-it, et tu écris {BACDE en bleu, et F en rouge} sur le premier, et {BACDF en bleu, et E en rouge} sur le second
- Et les post-it en question, tu les mets dans la boite 'TB_SCENARIO'
- Le post-it 'OLD_SCENARIO, celui que tu avais pris dans la boite TB_SCENARIO, tu le mets à la poubelle.
Et tu répètes l'opération autant que nécessaire (tant qu'il y a des post-it dans la boite)

Si tu fais ça à la main ... avec 6 lettres au départ, ça va être très long, mais avec 3 lettres au départ, ça devient raisonnable.
Le programme proposé fait exactement ça.

Edit :
J'ai mis beaucoup de temps à taper mon message, et du coup, nos messages se sont croisés.
Je suis moyennement convaincu par ton message de 16h55.. par exemple, à la fin tu ajoutes un truc n=n+1 .... pourquoi, je ne sais pas.

Je répète : le code que j'ai posté marche, il n'y a rien à ajouter, et rien à enlever...

Ceci-dit, il y a quelques fonctions qu'il faut interpréter/comprendre :
TableauAjoute : j'ai un post-it (pour reprendre l'image), et j'ajoute ce post-it dans une boite pleine de post-its.
TableauSupprime : le post-it que je viens de prendre de la boite, je le mets à la poubelle.
TableauOccurrence : Je compte combien il y a de post-its dans ma boite. En fait, le nombre précis de post-it qu'il y a dans la boite, il ne m'intéresse pas vraiment. J'ai juste besoin de savoir s'il y a au moins un post-it dans la boite, et de savoir récupérer le dernier post-it qui a été mis dans la boite.


Edit n°2 :
Scenar n'est pas une chaine, regarde le début du code, scenar est une structure composée de 2 chaines
Et scenar intervient dans la suite du programme : on affiche éventuellement scenar.schaine_a_remplir, on compte le nombre de caractères de scenar.schaine_a_vider , et on passe cette structure scenar comme parametre pour la sous-procédure avance_une_lettre.

[valentin03]

@: tbc92: Les langages informatiques sont une corruption de l'esprit en ce sens qu'il semble qu'on ne peux plus décrire un algorithme que dans les langages que l'on connaît; et plus en langage naturel en restant dans l'esprit de ce que fait la machine (dans les seuls termes de chaine, tableau, variable, index...ext (qui appartiennent au langage naturel)): le pseudo-code.
Mais je vais tenter aussi de transcrire tes boites et tes post-it. Je suis de type opiniatre-persévérant.
J'avoue que ma tentative précédente m'a contraint à un panic-down.
C'est pas gagné...

Edit: Le n=n+1 c'est juste le wend du while.

[valentin03]

J'aurais une question: Peut-on éviter la fonction et le passage en paramètre en utilisant deux tableaux en alternance ?

EDIT: Est-ce que pour cause d'abstraction, on ne peut pas traduire le passage en paramètre en pseudo-code ?

Suite:
Il ressort de ces quelques réponse qu'expliquer un code python de 10 lignes soit une entreprise trop ardue; de même que comprendre un algo dans un langage dont on ne connaît pas la syntaxe. Si je demande du pseudo-code, c'est pour COMPRENDRE!!!
L'abstraction et les poupées russes du python, c'est bien joli, mais si c'est pour au final ne pas pouvoir revenir de l'abstraction au concret et ne pas pouvoir expliquer 5 lignes de code; y a carrément un problème.

[tbc92]

Le problème n'est pas là.
Point 1 : Tu poses une question qui demande uniquement des connaissances en Python ; pose là sur un forum dédié à Python, tu t'adresseras à des gens qui connaissent Python. Personnellement, l'algorithmie est un truc qui me passionne, mais je ne connais rien à Python.

Point 2 : tu dis ou tu sens-entends que l'informatique, c'est un truc de tordus, et donc tu dis : 'aidez-moi, bande de tordus !' : tu imagines bien que les gens n'ont pas envie de te répondre. Te rendre service gratuitement, ok, mais se faire insulter en plus, bof !

[valentin03]

C'est bon, j'ai trouvé un code compréhensible (à la portée de mes pauvres neurones)
Je le mets là, ça peut toujours servir (c'est un Basic)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
  ' Pour info c'est pas rapide mais sans l'affichage (print) le temps est divisé par 10
  'n     Occur  Time
  '3     6
  '4     24
  '5     120
  '6     720
  '7     5 040  38 s
  '8     40 320  304 s
  '9     362 880  45 mn
  '10     3 628 800  7,30 h
  '11     39 916 800
  '12     479 001 600
  '13     6 227 020 800
  '14     87 178 291 200
  '15     1 307 674 368 000
  '16     20922789888000
  '17     355687428096000
  '18     6402373705728000
 'Le code:
s$="abcdefg"
  's$="abcdefghi" 'Time taken 19861
 's$="tsh73"
 
global ls, index
ls = len(s$) : index = 0
dim c$(ls)
t0 = time$("ms")   'mod
call orderperm s$
t1=time$("ms")     'mod
print "Time taken ";t1-t0   'mod
 
sub orderperm r$
    scan
    if len(r$) = 0 then
        'mod comment out for timed test,
        'mod comment in to see results
        index = index + 1
        print index;": ";
        for i = 1 to ls
            print c$(i);
        next
        print
    else
        lr = len(r$)
        for i = 1 to lr
            c$(ls - lr + 1) = mid$(r$, i, 1)
            r1$ = mid$(r$, 1, i - 1) + mid$(r$, i + 1)
            call orderperm r1$
        next
    end if
end sub

Merci quand même; sauf à flodelarab qui envoie les gens aux tutoriels (ce qui n'aide pas vraiment)

[wiwaxia]

... Merci quand même; sauf à ********** qui envoie les gens aux tutoriels (ce qui n'aide pas vraiment)

Il est pour le moins mesquin de restreindre ainsi l'expression de sa gratitude, et franchement impoli de le faire nommément ...

Renvoyer à des tutoriels est en soi une réponse tout à fait légitime, cela s'appelle le partage de connaissances
et fait partie de la vocation même de ce site:
IV-I. Avant de poser vos questions▲Commencez par parcourir le forum pour savoir si votre question n'a pas été déjà posée, le cas échéant utilisez l'option de recherche du forum, et pensez aussi à parcourir la FAQ et la liste des tutoriels sur http://www.developpez.com/ dans la section concernant le langage que vous utilisez. Il y a de grandes chances que votre réponse y figure déjà.

et l'intervenant mérite au moins quelques égards pour les informations qu'il s'est donné la peine de te fournir