Salut,
 
Je me pose en ce moment pas mal de questions sur les permutations...
 
J'aimerais savoir s'il existe des fonctions permettant de créer des permutations, et ce, quelque soit la taille du nombre d'éléments?
 
D'autre part, j'aimeraizs savoir si il existe des fonctions qui crée une permutation dépendant du parametre qu'on lui donne en entrée.
Par exemple, disons que j'ai 4 éléments, alors :
 
per(137) me retournerait {3, 2, 1, 4}
per(212) me retournerait {1, 2, 4, 3}
 
Et ainsi de suite, la permutation dépendant directement du parametre en entrée
 
Enfin, derniere question.... Quel est le moyen de plus simple (cad le plus rapide) d'inverser" une permutation
 
Par exemple inverser {3, 1, 4, 2} donne (2, 4, 1, 3)
 
Merci,
 
Yoyo*

 
 
 
int tab[NB_ELEMENTS];
for (int i=0;i<(NB_ELEMENTS/2);i++)
{
 tab[i] = tab[NB_ELEMENTS];
 tab[NB_ELEMENTS-i] = tab[i];
}

Oui, d'accord...
 
Et on peut assui prendre la permuation identité qui est mathématiquement une permutation...
 
Mais ce que je recherche, c'est une permutation un peu plus aléatoire, et surtout, qui dépende d'un parametre d'entrée... (et aussi dont la taille soit variable si ca peut exister??)
 
mais peut etre que je demande la lune?

un peu d'imagination et ca devrait le faire
EDIT : je veux bien passer qq minutes a chercher un peu un truc mais donne nous des details, des contraintes,...

fo que tu me réexpliques les notations pour les permutations...

Bon, alors je vous donne un peu les détails de ce que je voudrais faire...
 
Je voudrais opérer des permutations sur un message, histoire de le brouiller un peu (car de toute maniere, les algos de cryptage opérèrent octet par octet, et moi, je voudrais faire tourner un peu le tout)
 
Donc, voila!
 
Disons que pour le moment, la taille de mon message est fixe, disons 30 caracteres!
 
Je voudrais trouver une fonctions fPerm qui accepte un argument en entrée, par exemple un entier! C'est fonction doit me retourner en sortie un tableau "permuté" de 30 chiffres de 1 à 30, contenant, dans un ordre qui en fait dépend du parametre d'entrée.
 
Par exemple, je sais pas,
 
On obtiendrait :
fPerm(1) = [3, 28, 30, 7, 25, 6,...
fPerm(1256) = [1, 12, 2, 17, 13, 4,...
 
Vous voyez, la permutation obtenue dépendrait du paramzetre d'entrée.
 
Dans l'idéal, j'aimerais que cette fonction accepte en fait 2 parametres, un donnat la permutation, et un autre donnat la taille du tableau à permuter fPerm(clé, taille)
 
Par exemple :  
fPerm(1 ,3) = [1, 3, 2]
fPerm(2 ,3) = [1, 2, 3]
fPerm(12 ,4) = [1, 3, 4, 2]
 
Bien sur, je ne suis pas fixer sur la forme syntaxique de tout ca, mais j'aimerais trouver le  principe d'un algo qui puisse me permettre de faire tout ca...
 
Vous voyez?
 
Ce qui m'importe avant tout, c'est la possibilité, selon le parametre d'entrée de faire changer les permutations... La taille variable, c'est un "plus" !
 
 
 

pourquoi ne pas tout betement utiliser un cryptage du genre jules cesar???

 
Quel en est le principe?
 
Ce que je reproche aux techniques de cryptage, c'est que si tu demandes de crypter genre le message "abcdef", puis ensuite, tu demandes de crypter "abcdeg", les deux cryptogrammes se ressembleront beaucoup !
 
C'est donc pour ca que je voudrais pouvoir mélanger un peu mon résultat, et que ce mélange dépende d'un parametre , le fameux nombre entier dont je parle plus haut !

ça dépend des techniques de cryptage employées
De l'eau est passé sous les moulins depuis les crytages de type Jules César

jules cesar c'est tout juste ce qu'il te faut, c'est tres facile a mettre en place mais bon c'est decodable ultra facilement.
ca consiste a increment ou decrementer ton caractere un nombre donne de fois (ton parametre)
 
exemple:
"abcd" avec
+3 donnera "defg"
+5 donnera "fghi"
...
et pour decrypter tu fais -3

 
Zut, j'ai posté un message, mais il est pas passé...
 
Ce que je disais, c que justement, la technique de César n'est pas ce qu'il me faut, car comme d'ailleurs les algo de cryptage par flux, si on change juste une lettre, on peut se rendre compte que le message change peu, et donc, comprendre ou essayer de comprendre comment ca marche... Tandis qu'unmessage qui chage à "chaque coup", grace justement à une permutatyion, je trouve que c'est plus déroutant, et que pour l'amateur, ca ne donne meme pas envie de comprendre...
 
Donc voila pourquoi j'en reviens à ma question originale !

Pas de bol, c'est dans le prochain Knuth qui n'est pas encore sorti.

Knuth? Kesako? Ca sort quand?

pourquoi tu cherches a faire compliqué?
 
xor avec une clé et roulez

 
Nan, un XOR ne me convient pas car ca reste du "caractere par caractere", alors qu'avec une permutation, je peux mettre le chantier la dedans
 
Bon, en fait, j'ai un petite idée....
 
Mon idée consiste à utiliser la fonction Rand en utilisant à chaque fois une graine (Seed) différente, ce qui fait que la séquence de nombre générée sera différente! Alors, je fais à chaque fois Module mon nombre déléments, et à chaque nombre généré, je regarde si il a déja été généré, et si il ne l'a pas été, alors je lee range à la position suivante, le tout dans une boucle infinie jusqu'à ce que mon tableau soit rempli !
 
Ce truc me plait bien, et surtout, le pied, c'est qu'il est déterministe....(car la fonction rand est détermniste...)
 
Maintenant, le truc qui me plait pas, c'est que sans doute lafonction Rand n'est pas la meme quand on passe d'un langage à un autre....
 
Vous en pensez quoi?

je pense surtout que un si tu perumttes d'apres un rand ca va pas etre facile a depermutter tout ca
 
sauf si tu prends le bete rand, qui te renvoie toujours la meme sequence mais alors ca sert a rien.

 
Bah oui, je vais prendre le bete rand qui renvoie toujours la meme séquence, mais cette meme séquence dépend du parametre (le seed) que tu lui donnes, donc, à partir de ca, je peux considérer que je peux générer mes permutations, pour la taille que je veux, et aussi, dépendat d'un parametre, et ce, de maniere totalement déterminniste, ce qui fait qu'à l'arrivée, si je connais le parametre que j'ai mis à l'aentrée de mon rand, je pourrai retrouver la permuation !
 
Mainteannt, le dernier rempart est de savoir si tous les rand sont les memes, et ca, rien n'est moins sur....
 
Déja, je me demande si les rand de VBA Access97 et AccessXP sont les memes (c'est le pricinpal pour moi)
 
Ensuite, je ne pense pas que ceux de C++ et de VB soient les memes, fo pas rever....
 
Si y a trop d'incompatibilté, alros, il ne me restera qu'à générer une fonction pseudo aléatoire, genre mon propre rand !

tu comptes faire ton "crypteur" dans un langage et ton "decrypteur" dans un autre langage ou quoi?

 
Oui, ca pourrait arriver, dans le cas ou j'utilise une Dll C++ avec du VB ! Donc, le crypteur serait en C++, alors que le décrypteur serait en VB...
 
Et sinon, et là, c'est 100% probable, le truc pourrait etre crypté avec le VBA de Access97, alors que chez moi, ca sera décrypté avec du Access XP...
 
En fait, ce qui serait cool, c'est de pouvoir faire un Rad maison, mais bon...

http://www.google.com.ar/search?q= [...] l=es&meta=
J'en était sûr, qui d'autre que notre maître à tous pouvais sortir prenier sur google en mettant son nom dedans ?¿?
 
http://www-cs-staff.stanford.edu/~ [...] .html#vol4

 
Je viens de regarder un peu son site web, ca a l'air d'etre un éminent de notre monde
 
En attendant, quelqu'un à la solution à mon probleme? ou aurait un algo pour générer une suite de nombre pseudos aléatoires (pas la peine d'une grande théorie derrière, mais un truc simple m'irait !) Je tiens juste à ce que ma fonction soit déterministe !

là ça tourne au comique, tu en es conscient ?

 
Bah je suis surtout conscient que si je suis Mr knuth, je vais finir avec un truc "horriblement compliqué", alors que quand meme, le but du topic est de trouver quelque chose de simple résultat "efficace", algo assez simple (car implémenté en VB)...
 
Enfin, le bon sens quoi!
 
Si je cherchais quelque chose de vraiment poussé, je serais parti acheter un bouquin sur la théori e des permutations (et je sais qu'il y a de quoi écrire dessus, vu que j'ai fait prépa Maths...)

Tu ferais mieux de le lire au lieu de dire n'importe quoi !
une addition, une mutilplication et un modulo, ça va te tuer ?