Permutation de deux variables en pascal

Bon alors, après avoir planché sur ta question voici ma conclusion.
On peut permuter n'importe quels entiers A et B positifs qui vont de 0 à N-1 en faisant :

A := (A+B) mod N;
B := (A-B) mod N;
A := (A-B) mod N;

Donc avec des char ça donne :

A := ord (num(A)+num(B)) mod 256);
B := ord((num(A)-num(B)) mod 256);
A := ord((num(A)-num(B)) mod 256);

j'ai touvé ça mais je n'ai pas pu permuter deux variables de type char :
Pour les types "Réel" et "Entier"
0/Début PERMUT_Re_IN
1/Ecrire ("Saisir A"),lire(A)
2/Ecrire ("Saisir B"),lire(B)
3/<-A+B
4/A<-ABS(A-(A-B))
5/Ecrire(A)
6/Ecrire(B)
7/FIN PERMUT_Re_IN
Pour les types "Chaîne de caractères"
0/Début PERMUT_String
1/Ecrire ("Saisir A"),lire(A)
2/Ecrire ("Saisir B"),lire(B)
3/A<-CONCAT(A,B)
4/B<-COPY(A,1,(LENGTH(A)-LENGTH(B)))
5/DELETE(A,(LENGTH(A)-LENGTH(B)),LENGTH(B))
5/Ecrire(A)
6/Ecrire(B)
7/FIN PERMUT_String

Pour les types "Booléen"
0/Début PERMUT_Boolean
1/Ecrire ("Saisir A"),lire(A)
2/Ecrire ("Saisir B"),lire(B)
3/A <- A Xor B
4/B <- B Xor A
5/A <- A Xor B
6/Ecrire(A)
7/Ecrire(B)
8/FIN PERMUT_Boolean

Salut
Enfin j'ai trouver le solution parce même avec ord('a)+ord('b') on obtient une caractère donc cette manupilation devrait fonctionner :
program radh ;
uses wincrt ;
var a,b : char ;
begin
readln(a);
readln(b);
a := chr(ord(a)+ord(b));
b:= chr(ord(a)-ord(b));
a:=chr(ord(a)-ord(b) );
writeln(a);
writeln(b);
end.
Merci beaucoup KX pour tes grand efforts et .... Merci une autre fois ;)

Bon, je ne vois toujours pas l'intérêt de faire ce genre de chose, mais si tu y arrives avec un type entier, tu peux le faire facilement avec ton char avec les fonctions ord et num qui font les conversions integer<->char

Merci pour cet exemple de bidouille monstrueuse et inutile, j'en avais même pas trouvé ;-)

Si on parlait de données plus volumineuses je te conseillerai l'utilisation de pointeurs, il y aurait alors une permutation avec un pointeur intermédiaire.
Mais la taille d'un pointeur en mémoire doit-être à peu près celle d'un integer (donc plus grande qu'un char ou un booléen) donc il n'y a vraiment pas besoin de sortir les pointeurs dans ce cas précis.

D'ailleurs je ne vois vraiment pas l'intérêt de chercher à faire une permutation de types primitifs autrement qu'avec une variable intermédiaire...

Tu as essayé avec chr((ord(a)+ord(b)) mod 256) ?

Tu ne peux pas le faire à moins d'une bidouille monstrueuse et inutile.

tu peux le faire en passant par un bloc d'assembleur : ton char ou ton booléen tient sans problème dans AL

mais quand on fait chr (ord (a)+ord(b)) chr ne fonctionne pas car l'entier débasse le dernier entier dans le tableau des codes ASCII