---
# System prepended metadata

title: representation des nombres en machine

---

# representation des nombres en machine 

1.Variables et types de bases :

> Bouléen
String
Flottant		
Chaine de caractère
Expressions = var+ opérateurs
Types de langage info :
Langages interprétés :			Typages statique :
Typage dynamique			int toto=4 ;
Toto = 4 				(C, Java, C++)
=(python)

2.Les opérateurs de comparaison

> == sa teste l’égalité entre de truc
= définit une variable
3.Opérateur arithmétique :
[], ][
Z=not (a==b
Print(z)
variables et types de bases =
booléen
string 
chaine de caractère

2 types de language info =

> langages interprétés = typage dynamique
typage statistique
int toto=4 ;Toto = 4 (C, Java, C++)=(python)
2.Les opérateurs de comparaison==
sa teste l’égalité entre de truc=
définit une variable
#Opérateur arithmétique :[], ][Z=not
(a==b)Print(z)
expressions = var + opérateurs
opérateurs d’affectation

false and false = false
false and true = false
true and true = true

# operateurs appliqué aux chaine de caractere

# Bases de l'algorithmique
:::danger
attention : 

:::
## operateurs arithmetique
```python=
a=10
b=15
c=a+b   
print(c)
d=a/b 
print(d)
```
## operateur logique
```python=
e=a%2==0 #test de parite:ve   rifie si a est pair
f=a%2!=0
print(e)
print(f)      
``` 
## operateur de comparaison
```python=&
z=not(a==b)#on verifie si a=b via la variable (z)
print(z)
# operateur appliquer aux chaines de caracteres
```python=
p='toto'
q='titi'
m=p+q
print(m)
n=p*3
print(n)
m2=p+''+q+'\n'
pint(m2)
```


# les listes : []
# initialisation d'une liste a vide
lst = []
print(lst)

# Creation d'une liste contenat un type de base

lstint = [12, 56, 89]
lstfloat = [12.3, 56.5, 89.63]
lststring = ["a", "b", "titi"]
lstrandom = [1,"toto", 1.52, False]
print(lstint, lstfloat, lststring)

# Parcours d'une liste
# Parcours du contenu
for i in lstrandom:
    print(i)
# Parcours des positions/index
for i in range(len(lstrandom)):
    print("index :", i, "valeur :", lstrandom[i])
# les methodes dedies au listes
# Built-in
# Ajouter un element en fin de listes
lstrandom.append("coucou")
print(lstrandom)

# Ajouter un élement a une position donnee
lstrandom.insert(2,"Paris")
print(lstrandom) 
# Supprimer un element en derniere position
lstrandom.pop()

# Supprimer un element en premire position
lstrandom.pop(1)

# Supprimer un element a une position donnee
lstrandom.pop()

# Supprimer un element en fonction de sa valeur
lstrandom.pop()

# Ajout d'élement

dico2["Espagnol"]

#dictionnaires

dico1={"mathématique": 15, "français": 12, "histoire-géographie": 17,"anglais": 14}

dico1.update({"physique": 20})

for x, y in enumerate(dico1.items()):
    print(x, y)

# recuperation des clée d'un dico

#recuperation des valeursd'un dico
print(dico1.values())


moyenne=0

for k in dico1.values():
    moyenne+=k/5
print("la moyenne est de",str(moyenne))



# TP1 CHAP.2
TP1 Structures de données linéaires
# fonctions
'''On represente un point à l’aide de ses coordonnées stockées au sein d’un tuple (x,y).
Écrire une fonction milieu qui prend en paramètre un segment représenté par ses deux extrémités (p1,p2) et retourne les coordonnées de son milieu.'''

def milieu(s):
    x=(s[0][0]+s[1][0])/2
    y=(s[0][1]+s[1][1])/2
    return x,y # packing implicite
'''On représente une date par par un tuple (j,m,a) où. j est le jour du mois, m le numéro du mois et a l’année.

Les dictionnaires
# initialisation a vide
dico1 = {}
print(dico1)
dico2 = dict()
print(dico2)
# initialisation non vide
dico2 = {"Maths" : 12, "Fr" : 14, "EN" : 11}
print(dico2)
# ajout d'elements
dico2["Espagnol"] = 16

Exercice 1:
```python=
def milieu(s):
    x = (s[0][0]+s[1][0])/2
    y = (s[0][1]+s[1][1])/2
    return x,y # packing implicite

seg= (3,5), (10,5)
milieu(seg)
a = milieu(seg)
print(a)
````
Exercice 2: 
```python=
def anterieur(d1,d2):
    jour = d1[0]<d2[0]
    mois = d1[1]<d2[1]
    annee = d1[2]<d2[2]
    if annee:
        return True
    elif mois and d1[2]==d2[2]:
        return True
    elif jour and d1[1]==d2[1] and d1[2]==d2[2]:
        return True
    else:
        return False
date1 = (11, 7,1995)
date2 = (11, 7,1996)
date3 = (11, 7,2000)
date4 = (11, 9,1988)
c=anterieur(date1,date2)
b=anterieur(date2,date1)
d=anterieur(date3,date4)
e=anterieur(date4,date3)
print(c,b)
print(d,e)
```
Exercice 3: 
```python:
nom = (“hello”, “bonjour”)
date = (11, 9, 2001)

def nombre(nom, date):
 nombre = nom[1] + str(date[2])
return nombre
```
Exercie 4:

Écrire une fonction moyenne qui prend en entrée un tableau de nombres et retourne leur moyenne arithmétique.

```python=
def moyenne(liste=[]):
    somme = sum(liste) 
    nb_elements = len(liste)
    moyenne = somme / nb_elements
    return moyenne
print(5,10,15,20)
```

Exercice 5=

```python=
def est_ordonne (tab):
```

Exercice 6=
```python
tab = [(1,2),(6,4),(8,3)]

def unzip(tab):
result = tab[0][0] + tab[0][1]
result1 = tab[1][1] + tab[0][1]
result2 = tab[2][2] + tab[0][1]
return result
```
```python=
fonction zip(tab1 ,tab2):
    resultat = []
    for i in range (len(tab1)):
        resultat.append((tab1[i],tab2[i]))
    return resultat     


Exercice 7=
```python
def palindrome(a):
    lg=len(mot)
    for i in range(len(mot)//2):
        if mot[i]!=mot[lg-1-i]
            return False
    return True

a = (input("inserez un mot : "))

def verif():
if is_palindrome(a):
print(“Ce n’est pas un palindrome.”)
```
Exercice 9=
```python=
def longeur_mots(phrase):
    for i in phrase:
        a+=1
    else:
        tableau(a)
    return tableau
```
Exercice 10=
```python:
def Capitale(pays):
    =["Espagne":"Madrid"]
    return Capitale


TP1 Structures de données linéaires
# fonctions
'''On represente un point à l’aide de ses coordonnées stockées au sein d’un tuple (x,y).
Écrire une fonction milieu qui prend en paramètre un segment représenté par ses deux extrémités (p1,p2) et retourne les coordonnées de son milieu.'''

def milieu(s):
    x=(s[0][0]+s[1][0])/2
    y=(s[0][1]+s[1][1])/2
    return x,y # packing implicite
'''On représente une date par par un tuple (j,m,a) où. j est le jour du mois, m le numéro du mois et a l’année.

Les dictionnaires
# initialisation a vide
dico1 = {}
print(dico1)
dico2 = dict()
print(dico2)
# initialisation non vide
dico2 = {"Maths" : 12, "Fr" : 14, "EN" : 11}
print(dico2)
# ajout d'elements
dico2["Espagnol"] = 16



# TP1 :
Exercice 1:

2 + 3 * 5 + 4 == 21
(5 + 2) * 3 + 4 == 25
4 + 5 * (2 + 3) == 29
Exercice 2:

x = 0
x = 10

x < 10 and x > -10 
0 and 1 =0 
x < 10 or x > -10 
0 or 1 =1
x < 10 and x > -10 or x <= -10 and x > -15 and x == 10 and x >= -10
0 and 1 or 0 and 1 and 1 and 1 =0
Exercice 3:

s = 0
for i in range(10):
    s = s + i
    
s = 45 
    
s = 1
for i in range(1,6):
    s = s * i
   
    s = 120
    
    s = 0
while s < 20 :
    s = s + 5
    
    s = 0
while s != 100 :
    s = s * 2
    0
    0
    0
    ...
Exercice 4:

    
    pi = 3.14
def cicrconference(rayon):
    return pi*r*2

    print(circonference(10))

Exercice 5:

def nb_jours_mois(mois,annee):
    if mois in [4.6.9.11]:
        return(30)
    if mois in [1,3,5,7,8,10,12]
        return(31)
    
    if annee%4==0 and annee%100!=0 or annee%400==0
        return(29)
    else:
        return(28)
print(nb_jpurs_mois(12,2013))
Exercice 6:

def decrementer(n):
    while n>=0:
        print(n)
        n= n-1
decrementer(5)
Exercice 7:

def affiche_pairs(n):

    for i in range(0,n):
        if(i%2==0):
            print(i)

    return

affiche_pairs(20)
      


# TP2 :
Exerecice 1:

def nb_pairs(n):

    for i in range(4,20,2):
            print(i)

    return
Question 2:

a=2

while a<=20:
    if a%2==0:
        print(a)
        a=a+2

Question 3:

a=20
while a>=0:
    if a%2==0:
        print(a)
        a=a-2
Question 4:
1.

a = 10
b= 3

r = 0
while b !=0 :
    r = 10 % 3
    a = 3
    b = 10 % 3 = 1

r = 0
while b !=0 :
    r = 3 % 1
    a = 1
    b = 3 % 1 = 0
    
# Donc a=1 à la fin du programme
r = 0
while b !=0 :
    r = 10 % 15
    a = 15
    b = 10 % 15 = 10

r = 0
while b !=0 :
    r = 15 % 10
    a = 10
    b = 15 % 10 = 5

r = 0
while b !=0 :
    r = 10 % 5
    a = 5
    b = 10 % 5 = 0
    
# Donc a = 5 à la fin du programme
    
Utilisation des bibliothèques en Python:

Pandas est une bibliothèque permettant de travailler avec un tableaux de données comme sur Excel appelés sous le nom de DataFrames mais aussi avec des Panels, ensemble de données dites en trois ou quatre dimensions. Panda permet aussi de faire des calculs statistiques et de nommer les colonnes et les lignes ce qui est un avantage important par rapport aux autres bibliothèques du même style.

Numpy est une bibliothèque qui contient des modules de gestion de données et de calcul.L’avantage de Numpy est de pouvoir créer rapidement une base de données. Et d’effectuer des opérations sur un “array” Cela évite de devoir exécuter une boucle FOR ou une boucle WHILE, donc de gagner du temp.

SciPy est une bibliothèque qui offre un catalogue d’opérations scientifiques tels que: les algèbre linéaire, les algorithmes de régression, les fonctions statistiques… SciPy permet également de travailler dans l’ingénierie avec des fonctions physiques (par exemple le calcul de la pulsation d’un signal).

Matplotlib est une bibliothèque qui te permet, en une ligne de code, de créer des graphiques qui modélisent les données sur lesquelles tu travailles. Matplotlib offre une large variété de types de graphes.

Requests est une biblioyhèque qui est capable d’aller chercher sur le web une page dont on lui indique l’URL. On utilise pour cela la méthode .get(). Par exemple, pour obtenir le code HTML de la page Trustpilot qui compile les avis sur la formation Databird, on utilise :
‍

response = requests.get('https://fr.trustpilot.com/review/data-bird.co')
Bibliothèque random:

import random
def rires():
    rire = 'ha'
    val = int(random.random()*100)
    ri = rire * val
    print (val)
    print (ri)
    return
rires()
Bibliothèque math:

from math import sin
def affiche_sin():
    for i in range(0,314,2)
    t = i/100
    print(sin(t))
return
affiche_sin()  
def sin_string():
    for i in range(0,314):
        t = 1/100
        a = int(sin(t)*100)
        print('*'*a)
    return
sin_string()


TP 2=

melanger un  tableau =
             randint = de 0 a 5
             
pop -1 


EXO 1
# Inverser un dictionnaire
# Question 1 : 
# version 1 :
def inverse_dictionnaire(dico):
    resultat = {}
    for i in dico:
        resultat[dico[i]] = i 
    return resultat
# version 2 : 
def inverse_dictionnaire2(dico):
    resultat = dict() 
    for cle,val in dico.items(): 
        resultat[val]=cle 
    return resultat
# version 3 :
def inverse_dictionnaire3(dico):
    return {val:cle for cle,val in dico.items() }
# programme principal : 
# test fonction inverse_dictionnaire
capitales = {"France": "Paris", "Italie": "Rome"}
# version 1 
print(inverse_dictionnaire(capitales))
# version 2 
# version 3 
print(inverse_dictionnaire3(capitales))

EXO 2
On a besoin de s’assurer que les clés et les valeurs sont toutes les deux uniques autrement l’inversion au sein du dictionnaire est impossible.

exo 3

def carte_valide(carte):
    couleurs = ["Pique", "Coeur","Carreau", "Trèfle"]
    if type(carte[0]) == int and type(carte[1]) == str:
        if carte[0] > 1 and carte[0] < 15 and carte[1] in couleurs:
            return True
        else : 
            return False 
    else : 
        return False
print(carte_valide((5,"Pique")))
print(carte_valide((1, "Toto")))
print(carte_valide(("Titi", "Toto")))

EXO 4 =
# version 1
def nom_carte(carte):
    valeurs = {14 : "AS", 2 : "2", 3 : "3",
        4 : "4", 5 : "5", 6: "6", 7 : "7",
        9 : "9", 10 : "10", 11 : "Valet",
        8 : "8", 12 : "Dame", 13 : "Roi"
    }
    return valeurs[carte[0]] +" de "+ carte[1]
# version 2
def nom_carte2(carte):
    valeurs = {14 : "AS",  11 : "Valet", 
    12 : "Dame", 13 : "Roi"
    }
    if carte[0] >= 2 and carte[0]<= 10:
        return str(carte[0]) +" de "+ carte[1]
    else : 
        return valeurs[carte[0]] +" de "+ carte[1]    
# test 
print(nom_carte((14,"Pique")))
print(nom_carte2((14,"Pique")))

def tirage_aleatoire():
    jeu = jeux_cartes()
    index_carte = randint(1,52)
    return jeu[index_carte]
print(tirage_aleatoire())

EXO 5=
from random import randint

def melanger(tab):
    for x in range(len(tab)):
        # selection d'un index d'élement de façon aléeatoire
        y=randint(0,(len(tab)-1))
        # stockage de la valeur de l'element à supprimer dans une variable intermédiaire
        n=tab[y]
        # on retire l'élément d'indice y dans tab
        tab.pop(y)
        # on ajoute en dernière position l'élément retiré précédemment
        tab.append(n)
    return tab
t = [1,2,3,4,5]
print(melanger(t))

EXO 6 




``` python
# inverser un tableau
1/
``` python
nombresinv = []
nombres = list(range(11))

def inverse_tableau(nombres):
    indice = len(nombres)-1
    for i in range(indice):
        nombresinv.append(nombres[indice])
        indice = indice - 1
    print(nombresinv)

inverse_tableau(nombres)
```

2/

1/
```python=
lebouseuh = []
nombres = ['Messi' : 'Goat', 'Ronaldo' : 'Caca' ]

def inverse_tableau(nombres):
    a =len(nombres)-1
    for i in range(a):
        a=a- 1
    print(lebouseuh)
    
inverse_tableau(nombres)
```
appel de fonction = invers_tableau(nombres)
      
2/
```python=
chain2=''
def inverse_chaine(chaine):
    for i in chaine:
        chain2 = chaine - 1
    print(chain2)
    
inverse_chaine("Bonjour")
```
bonjour = ruojnob a fin de la fonction 
    ²                                


corrrection = 
```python=
def inverse_chaine(texte):
    a = texte 
    b = ''
    for lettre in texte:
        c = lettre + b 
        pr
    else : 
        for lettre in texte:
          c = lettre + b + c 
    print(c) 
```


    
    
    
    
    L’architecture dite architecture de von Neumann est un modèle pour un ordinateur qui utilise une structure de stockage unique pour conserver à la fois les instructions et les données demandées ou produites par le calcul. De telles machines sont aussi connues sous le nom d’ordinateur à programme enregistré. La séparation entre le stockage et le processeur est implicite dans ce modèle.
    
2.il a elements qui composent cette architecture 


3 et 4.
L'unité centrale de traitement (UC) effectue des opérations sur les données. Dans la plupart des architectures, elle se compose de trois parties : une unité arithmétique et logique (UAL), une unité de contrôle et un ensemble de registres.

5

Un processeur est un type particulier de microprocesseur. Il constitue le cœur de la plupart des ordinateurs, des appareils mobiles et autres appareils électroniques. Il transforme les données en instructions qui sont ensuite stockées dans la mémoire interne comparé au microprocesseur est un petit processeur spécialisé que l’on trouve dans de nombreux appareils électroniques
sagit d'un exemple d'ordinateurs de smartphones , d'apareils photo numeriques et d'autres appareils ellectroniques grand public  

6C’est le matériel de mémoire qui récupère/stocke les données à grande vitesse. Elle est également appelée mémoire temporaire. Les données dans la mémoire volatile sont stockées jusqu’à ce que le système en soit capable, mais une fois que le système est éteint, les données dans la mémoire volatile sont automatiquement supprimées. La RAM (Random Access Memory) et la mémoire cache sont des exemples courants de mémoire volatile. Ici, la récupération/le stockage des données est rapide et économique alors que la memoire non volatile C’est le type de mémoire dans lequel les données ou les informations ne sont pas perdues dans la mémoire même si l’alimentation est coupée. La ROM (Read Only Memory) est l’exemple le plus courant de mémoire non volatile. Ce n’est pas économique et lent en récupération/stockage par rapport à la mémoire volatile, mais stocke un volume de données plus élevé. Toutes ces informations qui doivent être stockées pendant une durée prolongée sont stockées dans une mémoire non volatile. La mémoire non volatile a un impact énorme sur la capacité de stockage d’un système.

7
Dispositif d’entrée	Dispositif de sortie
1.	Les données sont acceptées de l’utilisateur de l’appareil	
Il montre les données après traitement à l’utilisateur
3.	Il accepte les données de l’utilisateur et les transmet au processeur pour sauvegarde en mémoire secondaire ou traitement.	
Il reçoit les données du processeur et les renvoie à l’utilisateur.
4.Conception plus complexe	Conception moins complexe
7.	Ces appareils sont utilisés pour accepter les données	
Ces appareils sont utilisés pour afficher ou afficher les données
9.	Exemple : clavier, souris, etc.
Exemple : moniteur, imprimante, etc.


Exercice 1=

# q1 

sur des cartes perforées 

# Q2 
c'est le transitor

# Q3
c'est le language fortran 

# Q4
Apparu sur le marché en 1971  

# Q6
cpu et la memoire centrale 

# Q5 


# Q7 
le banc de registre , l'UAL 


# Q8
le bus 

# Q9 
il y a 3,3 milliards de cycle d'horloge differents

# Q10
 
# Q12

Le registre est un outil administratif de base pour les gouvernements : c’est le moyen idéal de contrôler une population sur un territoire

# Q13 

une machine de turing execute des actions tel que  lire ou ecrire se deplacer changer detat lors d'un cycle xd 




1=qu'est que la numeration positionnelle ?

elle permet de faire varier la valeur d'un chiffre/digit en fonction de sa position 
exemple = 111 
en partant de la droite , premier 1 vaut 1, le deuxieme 1 vaut 10 , le troisieme 1 vaut 100

2:que signifie le terme bit ?

-Le mot « bit » est la contraction des mots anglais binary digit
-quantité élemmentaire d'informations que l'on peut faire trannsiter entre deux machines 
-un bit prend deux valeurs entre 0 ou 1 


3: Quelle est la difference entre la numération romaine ou la numeration positionnelle ?

la notation romaine est dite additive; on additionne les differents chiffre qui composent le nombre pour obtenir le nombre total . ex = IV = 5-1

4 = Quels sont les systèmes de numération que nous utilisons au quotidien ? 

-  

5= Qu'est ce qu'une base dans un système de numération ?

une base dans un système de numeration est le nombre de symbole (de chiffres ) qui sont utilisés pour representer les nombres . 

## système de representation des nombres
Convention d'ecriture : 
- Base 10 = B<sub>10</sub>
- 10<sub>2</sub> = 2<sub>10 </sub> en décimal 
- 10<sub>10</sub> = 10 en décimal 
### sytème decimal ( base 10)
- Un chiffre peut prendre les valeurs comprise entre 0 et 9 
- Lorsque l'on atteint la valeur 9 dans un digit et qu'on souhaite incrémenter =
- on met tous les digits à droite à 0
- on crée un digit à gauche qui aura pour valeur 1
### le système héxadecimal (base 16)
#### Q1 : qu'est ce que le système hexadécimal ?
prennent une valeur entre 0 et 9 , ou entre A et F

#### Q2 : Dans quels cas utilisent-on le système hexadécimal ?
0<sub>16</sub> et FF<sub>16</sub>
#### Q3 : Compter de 0 jusqu'à 26 en hexadécimal 
0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,10,11,12,13,14,15,16,17,18,19,1A
#### Q4: Comment convertir un nb encodé en décimal vers l'hexadecimal 
decomposer le nombre decimal en somme de produit de nombres multipliés par 16 à la puissance d'entiers positifs : effectuer une divsion euclidienne par 16 jusqu'a obtenir un nombre inferieur à 16 
#### Q5 = Comment convertir un nombre encodé en hexadecimal vers le decimal 
remplacer chaque digit de A à F par 10 à 15 

### systeme binaire
1= 
le système binire est le système de numération utilisant la base 2. digit prennent une valeur entre 0 et 1 

#### Q2 DANS QUELS CAS UTILISE t'on le systeme binaire 
lors d'un transfert d'informations pour les machines 
#### Q3 
0,1,10,11,100,101,110,111,1000,1001,1010 ,10011 , 1100 , 1101 ;1110 , 1111 , 10000 , 10001 , 10010, 10011 , 10100 







**Qu’est-ce que la numération positionnelle?
**
la notation positionnelle permet de faire varié la valeur d’un chiffre/digit en fonction de sa position.
Exemple: 111 le “1” au milieu, vaut 10


**Que signifie le terme bit?**

« Bit » signifie binary digit
Quantité élémentaire d’information que l’ont peut faire transiter entre 2 machines
Un bit prend que deux valeurs au maximum 0 et 1


**Qu’est ce que la différence entre la notation romaine et conditionnelle?**

la notation romaine est dites additive, on additionne les differents chiffre qui composent le nombre pour obtenir le nombre total
Exemple: XV = 10+5=15


**Qu’est ce que qu’une base dans un sytème de numération?**

une base, dans un système de numération posittionnelle est le nombre de symbonles(des chiffres)qui sont utilisé pour représenter des nombres


**Quelle sont les système de numerétion que nous utilisons au quotidien?**

Base 12 pour les heures
Base 60 pour les minutes et les secondes
Base 24 pour les heures
Les systèmes de représentation des nombres
***Convention d’écriture:***

Base 10 = B10
Base 102 = 210 en binaire
Base 1010 = 10 en décimal
  

## Le système décimal (Base 10)

Dans le système décimal les chiffres prennent des valeures comprises entre 0 et 9.
Lorsque l’on atteint la valeure 9 au sein d’un digit, et qu’on souhaite incrémenter, on met tout les digits de droite à 0 et on crée un digit à gauche qui aura pour valeure 1.


## Le système hexadécimal (Base 16)

**Qu’est ce que le système héxadécimal ou à base 16 ?
**
Le système hexadécimal est un système de numération positionnel en base 16. Il utilise ainsi 16 symboles, en général les chiffres arabes pour les dix premiers chiffres et les lettres A à F pour les six suivants (en majuscule ou minuscule).

 c 
Dans quel cas l’utilise-t-on?

Le système hexadécimal est utilisé notamment en électronique numérique et en informatique
Comptez de 0 à 26 en héxadécimal
0123456789ABCDEF101112131415161718191A


Comment passe t’on du système hexadécimal en décimal?
Pour convertir en système décimal, multipliez chaque caractère (chiffre ou lettre) par la puissance de seize correspondante


Comment passe t’on du système décimal en héxadécimal?

Il faut dicviser par 16


Le système binaire (Base 2)

Qu’est ce que le système binaire ou à base 2 ?

Le système binaire (du latin binārĭus, « double ») est le système de numération utilisant la base 2. On nomme couramment bit (de l’anglais binary digit, soit « chiffre binaire ») les chiffres de la numération binaire positionnelle.


Dans quel cas l’utilise-t-on?

Le système binaire est utile pour représenter le fonctionnement de l’électronique numérique utilisée dans les ordinateurs.


Compter de 0 à 26 en binaire
0 0
1 1
2 10
3 11
4 100
5 110
6 101
7 111
8 1000
9 1001
10 1010
11 1 100
12 1 001
13 1 011
14 1 111
15 10 000
16 10 001
17 10 010
18 10 100
19 11 000
20 10 011
21 10 111
22 11 111
23 100 000
24 100 001
25 100 010
26 100 100


Comment passe t’on du système binaire en décimal?

Il faut écrire le nombre en puissance de deux en fonction de sa position .


Comment passe t’on du système décimal en binaire?

Le système de numérotation décimale (ou de base dix) est un système numérique dans lequel les chiffres peuvent prendre dix valeurs (0, 1, 2, 3, 4, 5, 6, 7, 8 ou 9). .

Comment passer de binaire a l’héxadécimal

On regroupe les nombres bianaires 4 ; il faut rajouter des 0 à gauche si le nombre fait moins de 4 bit, ensuite on se référe au tableau de conversion et on convertis les paquet à la suite.


Comment passer de l’héxadécimal au binaire

Pour passe de l’héxadécimal aux binaire on fait pareil que pour le binaire en héxa, on convertie l’héxadécimal chiffre par chiffre grâce à un tableau de conversion . 




## evaluation du nombre de bits nécessaires 

-Pour un entier positif sur n bits , on peut stocker 2  a puissances n entier postif 
-comme on doit coder l'entier nul , le plus grand entier postif qu'on peut representer est de à la puissance n-1
Pour evaluer le nombres de bits minimum necessaire à l'ecriture en base 2 d'un entier positif 
il trouver la plus petite puissance de 2 qui soit supérieure à l'entier à écrire 
exemple = on souhaite representer 200 en base 10 en binaire . Combien de bits sont nécessaires pour effectuer cela 
2^7<=200<=2^8
je conclue qu'il faut 8 bits pour representer en machine 200 .
-pour la somme de deux nombres entiers sans connaitre le resultat au préalable , le nombre des bits pour stocker la somme de 2 entiers postifs stocker sur n bits est n+1 bits 
- pour le produit de 2 nombres entiers sans connaitre le resultat au préalable , le nombre de bits nécessaire pour representer le produit de deux entiers représenté sur n bits est de 2 fois n bites 
-representation des entiers relatifs = 







# Activités: Représentation des nombres en machine : application du cours

1. 13*10¹+13*10^0 = 13



    
2. 1101
3. 15= 1110 
   . 25 = 11001
  
   
4. Le format RVB est un mode colorimétrique utilisé en informatique et qui permet de coder une couleur.

5. 117, 204, 225 en décimal

    6. rvb = 243 , 77, 193
                                 
integer Overflow 

1 . veut dire dépassement d'entiers en fr , il s'agit de prendre la valeur au-dessus 

### cours 

Pour évaluer le nombre de bit nécessaires pour représenter le nombre de complément à 2 il faut prévoir un bit supllementaire pour le bit de signe par rapport à la base binaire . 

Ainsi en complément à 2, on peut représenter n bit les valeurs entières les valeurs entières de -2 à la puissance n-1 2 à 2 la puissance n-1. 
 
Pour transformer un nombre en sont complément à 2 sans poser de calcul, il suffit de garder tout les bit depuis la droite jusqu'au premier 1 compris, puis d'inverser tout ceux qui sont à gauche du premier 1.































