modifications des tp, exercices, ajouts d'indications en JS, d'exemples en gloutons, 3 semaines de boulot enfin voilà
This commit is contained in:
259
gloutons/EXERCICES.md
Normal file
259
gloutons/EXERCICES.md
Normal file
@@ -0,0 +1,259 @@
|
||||
### Exercices - Algorithmes Gloutons
|
||||
|
||||
---
|
||||
|
||||
## Exercice 1 : Achat de V-Bucks (Fortnite)
|
||||
|
||||
Dans Fortnite, on peut acheter des V-Bucks avec les packs suivants : `{500, 1000, 2800, 5000, 13500}` V-Bucks.
|
||||
|
||||
Tu veux acheter exactement **8000 V-Bucks** en utilisant le moins de packs possible.
|
||||
|
||||
1. Appliquer l'algorithme glouton **à la main** pour obtenir 8000 V-Bucks. Combien de packs sont nécessaires ?
|
||||
2. Existe-t-il une meilleure solution ?
|
||||
3. Ce système est-il canonique (le glouton donne-t-il toujours l'optimal) ?
|
||||
|
||||
<details>
|
||||
<summary><strong>Voir la correction</strong></summary>
|
||||
|
||||
**Question 1 : Algorithme glouton**
|
||||
- On prend 5000 (le plus grand ≤ 8000) : reste 3000
|
||||
- On prend 2800 : reste 200
|
||||
- 200 < 500, on ne peut plus rien prendre !
|
||||
|
||||
L'algorithme glouton **échoue** à donner exactement 8000.
|
||||
|
||||
**Question 2 : Meilleure solution**
|
||||
- 8000 = 5000 + 1000 + 1000 + 1000 = **4 packs**
|
||||
- Ou : 8000 = 2800 + 2800 + 1000 + 1000 + 500 - 100... non ça ne marche pas non plus facilement.
|
||||
|
||||
En fait, 8000 = 5000 + 1000 × 3 = **4 packs** est la solution.
|
||||
|
||||
**Question 3 :**
|
||||
Non, ce système n'est pas canonique. L'algorithme glouton ne fonctionne pas toujours car les valeurs ne sont pas des multiples les unes des autres.
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
## Exercice 2 : Playlist Spotify optimale
|
||||
|
||||
Tu prépares une playlist pour un trajet de **60 minutes**. Tu veux y mettre le maximum de sons parmi tes favoris :
|
||||
|
||||
| Titre | Artiste | Durée (min) |
|
||||
|-------|---------|-------------|
|
||||
| Alibi | Sevdaliza | 4 |
|
||||
| La Kiffance | Naps | 3 |
|
||||
| Bande organisée | Jul & SCH | 6 |
|
||||
| Mood | 24kGoldn | 2 |
|
||||
| Fever | Dua Lipa | 3 |
|
||||
| Blinding Lights | The Weeknd | 3 |
|
||||
| Peaches | Justin Bieber | 3 |
|
||||
| Heat Waves | Glass Animals | 4 |
|
||||
| Iko Iko | Justin Wellington | 3 |
|
||||
| Astronaut in the Ocean | Masked Wolf | 2 |
|
||||
|
||||
**Objectif** : Maximiser le nombre de titres dans la playlist sans dépasser 60 minutes.
|
||||
|
||||
1. Quelle stratégie gloutonne proposez-vous ?
|
||||
2. Appliquer cette stratégie. Combien de titres obtenez-vous ?
|
||||
3. Quelle est la durée totale de la playlist ?
|
||||
|
||||
<details>
|
||||
<summary><strong>Voir la correction</strong></summary>
|
||||
|
||||
**Question 1 : Stratégie gloutonne**
|
||||
Pour maximiser le **nombre** de titres, on prend les titres **les plus courts en premier**.
|
||||
|
||||
**Question 2 : Application**
|
||||
Tri par durée croissante :
|
||||
- Mood (2 min) → total = 2
|
||||
- Astronaut in the Ocean (2 min) → total = 4
|
||||
- La Kiffance (3 min) → total = 7
|
||||
- Fever (3 min) → total = 10
|
||||
- Blinding Lights (3 min) → total = 13
|
||||
- Peaches (3 min) → total = 16
|
||||
- Iko Iko (3 min) → total = 19
|
||||
- Alibi (4 min) → total = 23
|
||||
- Heat Waves (4 min) → total = 27
|
||||
- Bande organisée (6 min) → total = 33
|
||||
|
||||
**Tous les 10 titres** rentrent dans 60 minutes !
|
||||
|
||||
**Question 3 :**
|
||||
Durée totale : **33 minutes**
|
||||
|
||||
*Note : Dans ce cas, la contrainte de 60 min n'était pas limitante. On aurait pu ajouter d'autres titres.*
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
## Exercice 3 : Inventaire Minecraft
|
||||
|
||||
Tu joues à Minecraft et ton inventaire peut contenir **64 objets** maximum. Tu veux maximiser la valeur totale des objets pour le commerce avec les villageois.
|
||||
|
||||
| Objet | Quantité dispo | Valeur (émeraudes) | Poids (slots) |
|
||||
|-------|----------------|-------------------|---------------|
|
||||
| Diamant | 10 | 8 | 1 |
|
||||
| Lingot d'or | 20 | 3 | 1 |
|
||||
| Fer | 50 | 1 | 1 |
|
||||
| Livre enchanté | 5 | 15 | 1 |
|
||||
| Émeraude | 30 | 1 | 1 |
|
||||
|
||||
*Chaque objet prend 1 slot, mais tu ne peux pas dépasser 64 slots au total.*
|
||||
|
||||
1. Calculer le ratio valeur/slot pour chaque objet.
|
||||
2. Appliquer l'algorithme glouton (meilleur ratio d'abord).
|
||||
3. Quelle est la valeur totale obtenue ?
|
||||
|
||||
<details>
|
||||
<summary><strong>Voir la correction</strong></summary>
|
||||
|
||||
**Question 1 : Ratios valeur/slot**
|
||||
|
||||
| Objet | Valeur | Ratio |
|
||||
|-------|--------|-------|
|
||||
| Livre enchanté | 15 | 15.0 |
|
||||
| Diamant | 8 | 8.0 |
|
||||
| Lingot d'or | 3 | 3.0 |
|
||||
| Émeraude | 1 | 1.0 |
|
||||
| Fer | 1 | 1.0 |
|
||||
|
||||
**Question 2 : Algorithme glouton**
|
||||
Tri par ratio décroissant, on prend dans l'ordre :
|
||||
- Livre enchanté : 5 objets → slots = 5, valeur = 75
|
||||
- Diamant : 10 objets → slots = 15, valeur = 75 + 80 = 155
|
||||
- Lingot d'or : 20 objets → slots = 35, valeur = 155 + 60 = 215
|
||||
- Émeraude : 29 objets (64-35=29) → slots = 64, valeur = 215 + 29 = 244
|
||||
|
||||
**Question 3 : Valeur totale**
|
||||
**244 émeraudes** avec 64 slots utilisés.
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
## Exercice 4 : Planning de stream Twitch
|
||||
|
||||
Tu es streamer et tu dois planifier tes lives pour demain. Plusieurs marques te proposent des partenariats avec des créneaux imposés :
|
||||
|
||||
| Sponsor | Début | Fin | Rémunération |
|
||||
|---------|-------|-----|--------------|
|
||||
| Red Bull | 14h | 17h | 200€ |
|
||||
| Logitech | 15h | 18h | 180€ |
|
||||
| Samsung | 17h | 19h | 150€ |
|
||||
| Razer | 18h | 20h | 120€ |
|
||||
| Discord | 19h | 21h | 100€ |
|
||||
| NordVPN | 20h | 22h | 90€ |
|
||||
|
||||
**Objectif** : Maximiser le nombre de partenariats (pas de chevauchement possible).
|
||||
|
||||
1. Quelle stratégie gloutonne permet de maximiser le **nombre** de streams ?
|
||||
2. Appliquer cette stratégie. Quels sponsors sélectionnez-vous ?
|
||||
3. Implémenter l'algorithme en Python.
|
||||
|
||||
<details>
|
||||
<summary><strong>Voir la correction</strong></summary>
|
||||
|
||||
**Question 1 : Stratégie**
|
||||
Pour maximiser le nombre d'activités, on trie par **heure de fin croissante** et on prend chaque activité compatible.
|
||||
|
||||
**Question 2 : Application**
|
||||
Tri par heure de fin : Red Bull (17h), Logitech (18h), Samsung (19h), Razer (20h), Discord (21h), NordVPN (22h)
|
||||
|
||||
- Red Bull (14h-17h) : OK
|
||||
- Logitech (15h-18h) : chevauche Red Bull, refusé
|
||||
- Samsung (17h-19h) : commence à 17h, Red Bull finit à 17h, OK
|
||||
- Razer (18h-20h) : chevauche Samsung, refusé
|
||||
- Discord (19h-21h) : commence à 19h, Samsung finit à 19h, OK
|
||||
- NordVPN (20h-22h) : chevauche Discord, refusé
|
||||
|
||||
**Sponsors sélectionnés : Red Bull, Samsung, Discord** = 3 streams
|
||||
|
||||
Rémunération totale : 200 + 150 + 100 = **450€**
|
||||
|
||||
**Question 3 : Code Python**
|
||||
|
||||
```python
|
||||
def planning_stream(sponsors):
|
||||
"""
|
||||
sponsors : liste de tuples (nom, debut, fin, remuneration)
|
||||
Retourne la liste des sponsors sélectionnés
|
||||
"""
|
||||
# Trier par heure de fin croissante
|
||||
sponsors_tries = sorted(sponsors, key=lambda x: x[2])
|
||||
|
||||
selection = []
|
||||
derniere_fin = 0
|
||||
|
||||
for nom, debut, fin, remuneration in sponsors_tries:
|
||||
if debut >= derniere_fin:
|
||||
selection.append((nom, debut, fin, remuneration))
|
||||
derniere_fin = fin
|
||||
|
||||
return selection
|
||||
|
||||
# Exemple d'utilisation
|
||||
sponsors = [
|
||||
('Red Bull', 14, 17, 200),
|
||||
('Logitech', 15, 18, 180),
|
||||
('Samsung', 17, 19, 150),
|
||||
('Razer', 18, 20, 120),
|
||||
('Discord', 19, 21, 100),
|
||||
('NordVPN', 20, 22, 90)
|
||||
]
|
||||
|
||||
planning = planning_stream(sponsors)
|
||||
total = sum(s[3] for s in planning)
|
||||
print("Sponsors sélectionnés :")
|
||||
for nom, debut, fin, remuneration in planning:
|
||||
print(f" {nom} : {debut}h - {fin}h ({remuneration}€)")
|
||||
print(f"Rémunération totale : {total}€")
|
||||
```
|
||||
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
## Exercice 5 : Réflexion
|
||||
|
||||
1. Dans l'exercice 4, on a maximisé le **nombre** de streams. Si on voulait maximiser la **rémunération totale**, l'algorithme glouton donnerait-il le même résultat ?
|
||||
|
||||
2. Parmi ces situations, lesquelles peuvent être résolues de manière optimale par un algorithme glouton ?
|
||||
- Choisir les meilleurs joueurs pour une équipe FIFA (budget limité)
|
||||
- Organiser l'ordre de visionnage de films sur Netflix (minimiser le temps total)
|
||||
- Rendre la monnaie avec des pièces européennes
|
||||
- Trouver le chemin le plus court dans Google Maps
|
||||
|
||||
<details>
|
||||
<summary><strong>Voir la correction</strong></summary>
|
||||
|
||||
**Question 1 :**
|
||||
Non ! Pour maximiser la rémunération, l'algorithme glouton pourrait donner un résultat différent.
|
||||
|
||||
Avec notre solution (Red Bull + Samsung + Discord) : 450€
|
||||
|
||||
Si on avait pris Red Bull (200€) + Razer (120€) + NordVPN (90€) : 410€ (moins bien)
|
||||
|
||||
Mais que se passe-t-il si on prend Logitech (180€) + Discord (100€) = 280€ ? C'est pire.
|
||||
|
||||
En fait, pour ce problème précis, la solution gloutonne par heure de fin est bonne, mais **maximiser la rémunération** est un problème différent (problème du sac à dos déguisé) qui ne se résout pas toujours de manière optimale avec un glouton.
|
||||
|
||||
**Question 2 :**
|
||||
|
||||
| Situation | Optimal avec glouton ? |
|
||||
|-----------|------------------------|
|
||||
| Équipe FIFA (budget) | Non (c'est un sac à dos) |
|
||||
| Ordre films Netflix | Ça dépend du critère... |
|
||||
| Monnaie européenne | Oui (système canonique) |
|
||||
| Google Maps | Non (Dijkstra n'est pas vraiment glouton au sens strict, mais utilise une approche similaire) |
|
||||
|
||||
</details>
|
||||
|
||||
----------
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>
|
||||
@@ -22,16 +22,16 @@ Selon le problème on utilise une méthode pour résoudre ce dernier. Il peut ex
|
||||
|
||||
À un problème d'optimisation, on associe une fonction objective.
|
||||
|
||||
Prenons un exemple simple : la liste des 23 joueurs selectionnés pour la coupe du monde :
|
||||
Prenons un exemple simple : la liste des 23 joueurs sélectionnés pour la coupe du monde :
|
||||
|
||||
```
|
||||
Didier Desvilles est bien embêté : il doit choisir 23 joueurs pour aller jouer une compétition.
|
||||
Dans cette optique, il décide d'utiliser une méthode simple: choisir le meilleur joueur possible pour chaque poste, puis le deuxième meilleur comme remplaçant.
|
||||
|
||||
Peu importe si les joueurs selectionnés ne s'entendent pas forcément très bien, comme Olivier Gibrun et Karim Benzemb, l'important c'est de faire le meilleur choix à chaque étape.
|
||||
Peu importe si les joueurs sélectionnés ne s'entendent pas forcément très bien, comme Olivier Gibrun et Karim Benzemb, l'important c'est de faire le meilleur choix à chaque étape.
|
||||
```
|
||||
|
||||
Un algorithme glouton ne renvoie pas obligatoirement un résultat optimal, dans ce cas la, on parle ***d'heuristique.*** Il renverra un résultat optimal pour chacun des sous-problèmes.
|
||||
Un algorithme glouton ne renvoie pas obligatoirement un résultat optimal, dans ce cas-là, on parle ***d'heuristique.*** Il renverra un résultat optimal pour chacun des sous-problèmes.
|
||||
|
||||
Un algorithme glouton ne revient pas sur un sous-problème déjà traité.
|
||||
|
||||
@@ -41,23 +41,19 @@ Un algorithme glouton ne revient pas sur un sous-problème déjà traité.
|
||||
|
||||
> Le problème du rendu de monnaie s'énonce de la façon suivante : étant donné un système de monnaie (pièces et billets), comment rendre une somme donnée de façon optimale, c'est-à-dire avec le nombre minimal de pièces et billets ?
|
||||
|
||||
On veut programmer une caisse automatique qui rend de façon optimal la monnaie (le moins de pièces/billets) :
|
||||
On veut programmer une caisse automatique qui rend de façon optimale la monnaie (le moins de pièces/billets) :
|
||||
|
||||
#### **Des exemples**
|
||||
|
||||
```
|
||||
Système de monnaie : ```{1, 2, 5, 10}```
|
||||
**Exemple 1 :**
|
||||
- Système de monnaie : `{1, 2, 5, 10}`
|
||||
- Recherché : `14`
|
||||
- Résultat optimal : `10 + 2 + 2` (3 pièces)
|
||||
|
||||
Recherché : ```14```
|
||||
|
||||
Résultat optimal : 10 + 2 + 2
|
||||
```
|
||||
|
||||
Système de monnaie : ```{1, 2, 5, 7, 10}```
|
||||
|
||||
Recherché : ```14```
|
||||
|
||||
Résultat optimal : 7 + 7
|
||||
**Exemple 2 :**
|
||||
- Système de monnaie : `{1, 2, 5, 7, 10}`
|
||||
- Recherché : `14`
|
||||
- Résultat optimal : `7 + 7` (2 pièces)
|
||||
|
||||
#### **Algorithme**
|
||||
|
||||
@@ -86,9 +82,9 @@ print(rendu_monnaie(systeme_2, 14)) # Devrait afficher [10, 2, 2] qui est non o
|
||||
|
||||
```
|
||||
|
||||
Force brute avec le ```system_2``` pour ```14```:
|
||||
Force brute avec le ```systeme_2``` pour ```14```:
|
||||
|
||||
On cherche **toute** les solutions possibles :
|
||||
On cherche **toutes** les solutions possibles :
|
||||
- \[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1\]
|
||||
- \[2, 2, 2, 2, 2, 2, 2\]
|
||||
- \[5, 5, 2, 2\]
|
||||
@@ -97,7 +93,7 @@ On cherche **toute** les solutions possibles :
|
||||
- \[10, 2, 2]
|
||||
- ...
|
||||
|
||||
On parcours la liste des solutions pour garder la solution la plus optimal (la plus courte) : **\[7, 7\]**.
|
||||
On parcourt la liste des solutions pour garder la solution la plus optimale (la plus courte) : **\[7, 7\]**.
|
||||
|
||||
### Exemples de problèmes que l'on peut résoudre par algorithme glouton
|
||||
|
||||
@@ -108,20 +104,131 @@ On parcours la liste des solutions pour garder la solution la plus optimal (la p
|
||||
|
||||
### **Sac à dos**
|
||||
|
||||
2 systemes : \[(valeur, poids)\]
|
||||
> Un voleur entre dans une maison avec un sac à dos pouvant contenir un poids maximum. Il trouve plusieurs objets, chacun ayant une valeur et un poids. Quels objets doit-il prendre pour maximiser la valeur totale sans dépasser la capacité du sac ?
|
||||
|
||||
- ```[(22, 11), (5, 5), (1, 1)]``` ;
|
||||
- ```[(12, 11), (10, 5), (10, 4), (1, 1)]```.
|
||||
#### Exemple
|
||||
|
||||
Pour un poids max de ```12```.
|
||||
Objets disponibles (valeur, poids) : `[(60, 10), (100, 20), (120, 30)]`
|
||||
|
||||
Plusieurs stratégies : **valeur/poids**, **le + de valeur** ou **le poids le plus gros**.
|
||||
Capacité du sac : `50 kg`
|
||||
|
||||
La fonction (et donc le résultat optimal) dépendra de la stratégie choisie.
|
||||
#### Stratégies gloutonnes possibles
|
||||
|
||||
1. **Prendre l'objet de plus grande valeur** en premier
|
||||
2. **Prendre l'objet le plus léger** en premier
|
||||
3. **Prendre l'objet avec le meilleur ratio valeur/poids** en premier (souvent la meilleure stratégie)
|
||||
|
||||
#### Algorithme (stratégie ratio valeur/poids)
|
||||
|
||||
```python
|
||||
def sac_a_dos_glouton(objets, capacite):
|
||||
"""
|
||||
objets : liste de tuples (valeur, poids)
|
||||
capacite : poids maximum du sac
|
||||
"""
|
||||
# Calculer le ratio valeur/poids et trier par ratio décroissant
|
||||
objets_avec_ratio = [(v, p, v/p) for v, p in objets]
|
||||
objets_tries = sorted(objets_avec_ratio, key=lambda x: x[2], reverse=True)
|
||||
|
||||
poids_total = 0
|
||||
valeur_totale = 0
|
||||
sac = []
|
||||
|
||||
for valeur, poids, ratio in objets_tries:
|
||||
if poids_total + poids <= capacite:
|
||||
sac.append((valeur, poids))
|
||||
poids_total += poids
|
||||
valeur_totale += valeur
|
||||
|
||||
return sac, valeur_totale, poids_total
|
||||
|
||||
# Exemple d'utilisation
|
||||
objets = [(60, 10), (100, 20), (120, 30)]
|
||||
capacite = 50
|
||||
|
||||
sac, valeur, poids = sac_a_dos_glouton(objets, capacite)
|
||||
print(f"Objets pris : {sac}")
|
||||
print(f"Valeur totale : {valeur}, Poids total : {poids}")
|
||||
# Résultat : [(60, 10), (100, 20)] avec valeur=160 et poids=30
|
||||
# Note : ce n'est pas optimal ! L'optimal serait [(100, 20), (120, 30)] = 220
|
||||
```
|
||||
|
||||
> **Attention** : L'algorithme glouton ne donne pas toujours la solution optimale pour le problème du sac à dos !
|
||||
|
||||
---------
|
||||
|
||||
### **Voyageur de commerce**
|
||||
|
||||
Le problème du **voyageur de commerce**, est un problème d'optimisation qui, étant donné une liste de villes, et des distances entre toutes les paires de villes, détermine un plus court circuit qui visite chaque ville une et une seule fois.
|
||||
> Un voyageur de commerce doit visiter plusieurs villes exactement une fois, puis revenir à son point de départ. Quel est le chemin le plus court ?
|
||||
|
||||
#### Exemple
|
||||
|
||||
Imaginons 4 villes : A, B, C, D avec les distances suivantes :
|
||||
|
||||
| De/Vers | A | B | C | D |
|
||||
|---------|---|---|---|---|
|
||||
| A | - | 10 | 15 | 20 |
|
||||
| B | 10 | - | 35 | 25 |
|
||||
| C | 15 | 35 | - | 30 |
|
||||
| D | 20 | 25 | 30 | - |
|
||||
|
||||
#### Stratégie gloutonne : "Plus proche voisin"
|
||||
|
||||
À chaque étape, on se déplace vers la ville non visitée la plus proche.
|
||||
|
||||
```python
|
||||
def voyageur_commerce_glouton(distances, depart=0):
|
||||
"""
|
||||
distances : matrice des distances entre villes
|
||||
depart : indice de la ville de départ
|
||||
"""
|
||||
n = len(distances)
|
||||
visitees = [False] * n
|
||||
chemin = [depart]
|
||||
visitees[depart] = True
|
||||
distance_totale = 0
|
||||
|
||||
ville_actuelle = depart
|
||||
|
||||
for _ in range(n - 1):
|
||||
# Trouver la ville non visitée la plus proche
|
||||
plus_proche = None
|
||||
dist_min = float('inf')
|
||||
|
||||
for ville in range(n):
|
||||
if not visitees[ville] and distances[ville_actuelle][ville] < dist_min:
|
||||
dist_min = distances[ville_actuelle][ville]
|
||||
plus_proche = ville
|
||||
|
||||
# Se déplacer vers cette ville
|
||||
chemin.append(plus_proche)
|
||||
visitees[plus_proche] = True
|
||||
distance_totale += dist_min
|
||||
ville_actuelle = plus_proche
|
||||
|
||||
# Retour au point de départ
|
||||
distance_totale += distances[ville_actuelle][depart]
|
||||
chemin.append(depart)
|
||||
|
||||
return chemin, distance_totale
|
||||
|
||||
# Exemple d'utilisation
|
||||
distances = [
|
||||
[0, 10, 15, 20], # Distances depuis A
|
||||
[10, 0, 35, 25], # Distances depuis B
|
||||
[15, 35, 0, 30], # Distances depuis C
|
||||
[20, 25, 30, 0] # Distances depuis D
|
||||
]
|
||||
|
||||
chemin, distance = voyageur_commerce_glouton(distances, depart=0)
|
||||
villes = ['A', 'B', 'C', 'D']
|
||||
chemin_noms = [villes[i] for i in chemin]
|
||||
print(f"Chemin : {' -> '.join(chemin_noms)}")
|
||||
print(f"Distance totale : {distance}")
|
||||
# Résultat : A -> B -> D -> C -> A avec distance = 80
|
||||
```
|
||||
|
||||
> **Note** : Le problème du voyageur de commerce est un problème **NP-difficile**. Pour un grand nombre de villes, trouver la solution optimale prend un temps exponentiel. L'approche gloutonne donne une solution acceptable rapidement, mais rarement optimale.
|
||||
|
||||
--------
|
||||
|
||||
|
||||
Reference in New Issue
Block a user