Le binaire expliqué aux cons

Ah merde, je m'attendais à une suite avec les applications de tout ça...

Le binaire, c'est vraiment un truc qui fout les booles.

Ca me rappel mes débuts en binaire ou j'avais un mal de tête terrible à essayer de comprendre cette merde. Et l'appliquer encore mais pensez au mecs qui ont inventés le binaire, il devait avoir une misérable vie pour penser à faire du mal aux gens comme ça.

C'est utile face à un ours Kodiak?

Oui, ça l'endort.
* retourne saccager des ruches*

Ceacy a écrit :
fout les booles.

1o1

L'algebre des booles ?

Ca fait mal.

C'est comme une gonzesse, quoi.
(j'édite et je précise: le binaire)

Niourk a écrit :

C'est utile face à un ours Kodiak?

Ah, l'ours. Toujours lui.

Un anneau de Boole est un anneau (E, +, .) dans lequel tout élément de A est idempotent (x.x = x).
On a donc, par définition :
+ une loi de composition interne de E commutative, telle que (E, +) soit un groupe commutatif (d'où E non vide, car contenant au moins un élément neutre)
. une loi de composition interne associative et distributive par rapport à +

L'ensemble E={0,1} muni de la relation logique OU (notée +) et de la loi logique ET (notée .) est un anneau commutatif de Boole (i.e, la loi . est également commutative). En effet :
- E est non vide
- Quel que soit x élément de E, 0+x=x+0=x : 0 est l'élément neutre par rapport à +
- Quels que soient x,y éléments de E, x+y appartient à E (+ est bien une loi de composition interne)
- Quels que soient x,y éléments de E, x+y=y+x (commutativité)
- Quels que soient x,y,z éléments de E, (x+y)+z=x+(y+z)=x+y+z (associativité)
- Quel que soit x élément de E, 1.x=x.1=x : 1 est l'élément neutre par rapport à .
- Quels que soient x,y éléments de E, x.y appartient à E (. est bien une loi de composition interne)
- Quels que soient x,y éléments de E, x.y=y.x (commutativité)
- Quels que soient x,y,z éléments de E, (x.y).z=x.(y.z)=x.y.z (associativité)
- Quels que soient x,y,z éléments de E, z.(x+y)=z.x+z.y (distributivité de . par rapport à +)
De plus, 0.0=0 et 1.1=1 , donc x.x=x est vérifié pour tout x de E (et si je me suis trompé de loi pour démontrer la propriété, ce n'est pas grave, ça fonctionne avec les deux.)

Et là, l'ours est parti chier.

D'ailleurs, je crois que ce que j'ai raconté est légèrement faux.

j'allais le dire

carwin a écrit :
C'est comme une gonzesse, quoi.
(j'édite et je précise: le binaire)

Non mais dites ! Pourriez-vous préciser votre pensée Môssieur, je ne suis pas sure de comprendre ?

Marmotte a écrit :
je ne suis pas sure de comprendre ?

CQFD

camaieeuh a écrit :

Marmotte a écrit :
je ne suis pas sure de comprendre ?

CQFD

Maychant §§§

J'ai pas résisté à la tentation, désolé.

OMG mais il est nul ton jeu LOL

Pour déconner, on pourrait compte en base 3 par exemple


Avec les symboles ABC.

C'est vrai qu'avec les symboles 1,2 et 3 ç'aurait été trop difficile....

Maintenant, encore plus drôle : le code Gray.
Il s'agit d'un "pseudo-binaire", utilisé notamment pour certaines applications comme els codes-barres, et tel qu'entre n et (n+1) seul un bit change d'état. De plus, il y a une symétrie à la con, ou presque.
000000 : 0
000001 : 1
000011 : 2
000010 : 3
000110 : 4
000111 : 5
000101 : 6
000100 : 7
001100 : 8
001101 : 9
001111 : 10
001110 : 11
001010 : 12
001011 : 13
001001 : 14
001000 : 15
(il me semble, la flemme de vérifier).
Le code gray est aussi appelé binaire réfléchi, et tenter de l'apprendre tout en découvrant le binaire est très amusant.

carwin a écrit :
C'est comme une gonzesse, quoi.
(j'édite et je précise: le binaire)

Ah oui mais non, une gonzesse c'est comme du binaire mais avec uniquement le 0.

gwendal a écrit :
Ca me rappel mes débuts en binaire ou j'avais un mal de tête terrible à essayer de comprendre cette merde. Et l'appliquer encore mais pensez au mecs qui ont inventés le binaire, il devait avoir une misérable vie pour penser à faire du mal aux gens comme ça.

Pour la petite histoire, sans le code binaire point d'ordinateur. Je crois qu'il y a déjà eu des tentatives de microprocesseur en décimal ou hexa mais les types s'en occupant ont du se pendre. Et encore il leur restait le stockage, un disque dur avec des plateaux à 10 ou 16 états différents je connais pas.

Puisque tu aimes vraiment les codages, je te conseille de programmer en assembleur. En principe tu as des adresses mémoires en hexa avec un contenu binaire. Tu devrais apprécier :)

Ceacy a dit:
{
Ah, l'ours. Toujours lui.

Un anneau de Boole est un anneau (E, +, .) dans lequel tout élément de A est idempotent (x.x = x).
On a donc, par définition :
+ une loi de composition interne de E commutative, telle que (E, +) soit un groupe commutatif (d'où E non vide, car contenant au moins un élément neutre)
. une loi de composition interne associative et distributive par rapport à +

L'ensemble E={0,1} muni de la relation logique OU (notée +) et de la loi logique ET (notée .) est un anneau commutatif de Boole (i.e, la loi . est également commutative). En effet :
- E est non vide
- Quel que soit x élément de E, 0+x=x+0=x : 0 est l'élément neutre par rapport à +
- Quels que soient x,y éléments de E, x+y appartient à E (+ est bien une loi de composition interne)
- Quels que soient x,y éléments de E, x+y=y+x (commutativité)
- Quels que soient x,y,z éléments de E, (x+y)+z=x+(y+z)=x+y+z (associativité)
- Quel que soit x élément de E, 1.x=x.1=x : 1 est l'élément neutre par rapport à .
- Quels que soient x,y éléments de E, x.y appartient à E (. est bien une loi de composition interne)
- Quels que soient x,y éléments de E, x.y=y.x (commutativité)
- Quels que soient x,y,z éléments de E, (x.y).z=x.(y.z)=x.y.z (associativité)
- Quels que soient x,y,z éléments de E, z.(x+y)=z.x+z.y (distributivité de . par rapport à +)
De plus, 0.0=0 et 1.1=1 , donc x.x=x est vérifié pour tout x de E (et si je me suis trompé de loi pour démontrer la propriété, ce n'est pas grave, ça fonctionne avec les deux.)

Et là, l'ours est parti chier.
}
Tu peux faire simple steup!

N'empêche, c'était cool 2006.

Def a écrit :
...
Puisque tu aimes vraiment les codages, je te conseille de programmer en assembleur. En principe tu as des adresses mémoires en hexa avec un contenu binaire. Tu devrais apprécier :)

J'en profite pour corriger :

Le langage assembleur utilise des mnémoniques et est donc compréhensible par l'être humain (JSR, BNE, ADD, ...).

Le langage machine, lui, n'utilise que des valeurs numériques.

Le binaire, c etait mieux avant.

Dans la vie, il y a 10 catégories de personnes : ceux qui comprennent le binaire, et ceux qui ne le comprennent pas.

Def a écrit :
Puisque tu aimes vraiment les codages, je te conseille de programmer en assembleur. En principe tu as des adresses mémoires en hexa avec un contenu binaire. Tu devrais apprécier :)

J'ai donné, à l'époque sur un ZX81 et sur un CPC6128 pour cracker les jeux et être le roi du monde.

Puis après j'ai commencé à vivre donc je me suis mis à boire et j'ai oublié ce que j'avais appris.

ZX81 : Mon premier ordi \o/

Holly fucking Christ, 2006 ! joli déterrage

jvous owne avec mon ZX Spectrum +