Bonjour,
je suis débutant, je souhaite mettre en place une table de vérité avec java(algèbre de bool), mais franchement je n'ai aaucune idee!!, alors si qulqu'un peut me donner une piste, merci.
Quand tu dis "table de vérité" tu parles d'un tableau de vraix ou faux ? (boolean)
ou bien même principe qu'en électronique ?
je vai prendre le deuxième cas
tu veux faire une table ? ou juste l'opérateur ?
voici la fonction "ET" implémentée ...
tu rentre 2 "colonnes" de boolean qui doivent avoir la même taille
et ça te sort la réponse.
public static boolean[] VeritasET(boolean[] Col1, boolean[] Col2) throws NotSameSizeExeption
{
if(Col1.length != Col2.length){throw new NotSameSizeExeption()} // cette ligne n'est pas nécessaire
//mais c'est quand même mieux avec
boolean[] retour = new boolean[Col1.length];
for(int i =0; i<Col1.length ; i++){
if(Col1[i] && Col2[i]){retour[i] = true;}else{retour[i] = false;}
}
return retour;}
voici le code pour implémenter le "OU" kif kif le même seul le "IF" change (&& deviens ||)
public static boolean[] VeritasOU(boolean[] Col1, boolean[] Col2) throws NotSameSizeExeption
{
if(Col1.length != Col2.length){throw new NotSameSizeExeption()} // cette ligne n'est pas nécessaire
//mais c'est quand même mieux avec
boolean[] retour = new boolean[Col1.length];
for(int i =0; i<Col1.length ; i++){
if(Col1[i] || Col2[i]){retour[i] = true;}else{retour[i] = false;}
}
return retour;}
voilà maintenant on va faire une fonction qui suit une instruction de type String
dans mon exemple je ne vais pas traiter le cas des () je te laisse chercher
donc le String operation est du genre "1:.:2:+:3:.:1:.:5" ou le . représente le ET logique et le + le ou logique. et les chiffrs représentent la colonne
sait pas si c'est la meilleurs des méthodes mais bon
pour faire mieux tu devrais créer une classe spéciale qui contiens la suite des instruction a faire
en plus des différents tableaux
voilà j'espere avoir été claire et pas avoir raconté de conneries
de plus n'oublie pas que tu peux travailler directement avec des nombre en base 16 et faire toutes les opérations de l'algèbre de bool dessus.
Voici un exemple rapide
public class Bool {
public static void main(String[] args) {
int a = 0x3; // 0011 en binaire 4 bits
int b = 0x4; // 0100 *****************
System.out.println("Affiche des nombres en binaire");
System.out.println(Integer.toBinaryString(a)); // Affiche a sous forme binaire
System.out.println(Integer.toBinaryString(b)); // Affiche b sous forme binaire
int ou = a | b; // Opérateur bit à bit
int et = a & b;
System.out.println("\nAffichage des nombre avec opération");
System.out.println(Integer.toBinaryString(ou));
System.out.println(Integer.toHexString(ou));
System.out.println(Integer.toBinaryString(et));
System.out.println(Integer.toHexString(et));
}
}
Si tu a d'autres questions n'hésite pas
Le développement de jeu vidéo vous intéresse ? Parlons en !
Et bien dans un premier temps, ça peut te servir à faire des opérations sur des gros nombre, car travailler avec des booléen c'est bien pour les petits nombre, mais des que tu augmente, autent travailler directement en hexa. J'ai été confronté au problème l'année dernière quand je me suis lancer dans la programmation d'un processeur, au début je fonctionnais avec des tableaux de booléens pour stocker des mots binaires 4 bits, mais j'ai vite été limité par ce principe quand j'ai voulu faire faire à mon UAL des opération arithmétique. Si tu veux un peu plus de doc sur le sujet je te conseil ce lien et celui ci aussi.
Voici un exemple qui permet de réaliser des multiplication et division avec les opérateur bit à bit (bitwise) :
public class Bool {
public static void main(String[] args) {
int nombre = 45, // Pour multiplication
nombre2 = 90; // Pour division
int tab[] = new int[5];
int tab2[] = new int[5];
/*
* On réalise une simple multiplication
*
* tab[0] = 45 << 0 = 45 * 1 = 45
* tab[1] = 45 << 1 = 45 * 2 = 90
* tab[2] = 45 << 2 = 45 * 4 = 180
* tab[3] = 45 << 3 = 45 * 8 = 360
* tab[4] = 45 << 4 = 45 * 16 = 720
*
*/
for (int i = 0 ; i < tab.length ; i++) {
tab[i] = nombre << i;
}
// On affiche
for (int i : tab) {
System.out.println(i);
}
// ######################################################
/*
* On réalise une simple division
*
* tab[0] = 45 >> 0 = 90 / 1 = 90
* tab[1] = 45 >> 1 = 90 / 2 = 45
* tab[2] = 45 >> 2 = 90 / 4 = 22
* tab[3] = 45 >> 3 = 90 / 8 = 11
* tab[4] = 45 >> 4 = 90 / 16 = 5
*
*/
for (int i = 0 ; i < tab2.length ; i++) {
tab2[i] = nombre2 >> i;
}
// On affiche
for (int i : tab2) {
System.out.println(i);
}
}
}
Cela va bien entendu en complément de ce que j'ai dit plus haut, l'avantage d'utiliser cette méthode est quand on l'utilise avec des nombre hexadécimaux. On pourra noter que faire une multiplication ou division comme ceci est plus rapide que d'écrire : intp=4/2;
Le développement de jeu vidéo vous intéresse ? Parlons en !
A | B | S
----------
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 1
Comme tu le constate tant qu'une des variable est vrai alors la variable S est vrai.
Table de vérité du Ou Exclusif (XOR)
A | B | S
----------
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 0
Ici c'est caractéristique, on voit que la sortie est vrai uniquement si une et une seul variable est vrai, en effet quand les deux valent 0 S vaut 0, quand les deux valent 1 S vaut 0 aussi, d'où le terme "exclusif", on dit que la variable {a ou b} a l'exclusivité sur la variable S.
Citation : Snooooopy
il y'a un opérateur ou 0 0 -> 1 ??
Si justement c'est grâce à l'opérateur inverseur noter '~' (prononcer "non" ou "not"), on dit aussi négation en arithmétique. Avec cet opérateur tu peux faire de nouveaux opérateurs.
Table de vérité du Non (ou Not)
A | S
------
0 | 1
1 | 0
S vaut l'inverse de A, de la tu peux faire des opérateur non-ou (NOR) non-et (NAND)...
Table de vérité du Non-Ou (NOR)
A | B | S
----------
0 | 0 | 1
0 | 1 | 0
1 | 0 | 0
1 | 1 | 0
Oui c'est l'inverse du Ou, idem pour les autres opérateurs. Pour en revenir à Java, tu peux faire la même chose avec les opérateurs bit à bit :
~ : inverseur (not)
& : et (and)
| : ou (or)
^ : ou-exclusif (xor)
J'espère avoir répondu à tes questions. Voici un lien qui résume la chose si je puis dire Et un autre lien sur l'arithmétique (1er chapitre de math en DUT informatique lol)
+
Le développement de jeu vidéo vous intéresse ? Parlons en !
t'es un génie
je vais pouvoir simuler des processeur *_* en java
claasse ça m'aurais été pratique l'année passée je devais faire une détections de badge et on fonctionnais en comparent 2 valeur binaire justement
si tu veux simuler un processeur je te conseil de bien connaitre l'architecture système, car c'est pas très simple au debut entre les registres, les timers, les codeop ET LES INTERRUPTIONS xDD etc... Toutes les doc sur l'ASM sont super enrichissante d'ailleurs, d'ailleurs si asm est java t'interesse, je te conseil de faire un tour içi (l'équipe de jpcsp s'en sert pour son dynarec )
Le développement de jeu vidéo vous intéresse ? Parlons en !
bah je verrai j'aurais probablement besoins de le faire vus que je suis en option électronique de polytech
mais la j'ai bisser
donc je sais que je devrai le faire un jours mais je sais pas quand
mais chaque chose en son temps je maitrise pas assez ni java ni électronique
donc la j'approfondis
java
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
"'But I don't want to go among mad people,' said Alice. 'Oh, you can't help that,' said the cat. 'We're all mad here.'" Lewis Carroll