Skip to main content Informatique en prépa - Lycée Malherbe 

Mines 2023 - La typographie informatisée

Le sujet

Épreuve d'informatique commune (MP, PC, PSI) du concours Mines-Ponts 2023, en 2 heures. Sujet original (PDF), © GIP CCMP, publié sous licence Creative Commons BY-NC-ND 3.0 France.

L'énoncé est reproduit tel quel. Les cellules de code, les vérifications, les affichages et la base de données ont été ajoutés pour le traiter sur machine : la base de données est fictive (la police « Triangle » de l'énoncé y a été complétée). Les figures du sujet ne sont pas reproduites.

Ce sujet explore quelques aspects de la typographie informatisée. Il aborde la gestion de polices vectorielles, leur manipulation, leur tracé, l'affichage de texte et la justification d'un paragraphe. Il va du texte à la page via le pixel. Les questions posées peuvent dépendre des questions précédentes. Toutefois, une question peut être abordée en supposant les fonctions précédentes disponibles, même si elles n'ont pas été implémentées. Les questions de programmation seront traitées en Python.

Partie I – Préambule

La typographie est l'art d'assembler des caractères afin de composer des pages en vue de leur impression ou de leur affichage sur un écran, en respectant des règles visuelles qui rendent un texte agréable à lire. Elle requiert des efforts importants, avantageusement simplifiés par le recours à l'outil informatique.

Donald Knuth, prix Turing 1974 notamment pour la monographie The Art of Computer Programming, en est un pionnier. Lassé de la piètre qualité de la typographie proposées pour son ouvrage, il développe les logiciels TeX pour la mise en page et METAFONT pour la gestion de polices. Leslie Lamport, prix Turing 2013 pour ses travaux sur les systèmes distribués, a écrit LaTeX qui facilite l'utilisation de TeX. LaTeX est largement utilisé dans l'édition scientifique, y compris pour la composition du présent document.

Donald Knuth récompense toute personne qui signale une nouvelle erreur dans un de ses ouvrages par un chèque d'un montant de un hexa dollar, c'est-à-dire 100 cents où 100 est interprété en base hexadécimale (base 16).

Q1

Quel montant est effectivement versé en dollars par Donald Knuth pour une nouvelle erreur trouvée ?

Réponse

Voici la définition de quelques termes utiles pour la suite :

Le corps du glyphe est sa hauteur, la chasse est sa largeur. Le corps est décomposé en trois parties : l'œil qui contient typiquement les petites lettres, le jambage et la hampe qui recouvrent les dépassements en dessous ou au dessus de l'œil. La limite inférieure de l'œil est la ligne de base. Elle définit l'alignement des caractères. La chasse peut être fixe (polices monospaces) ou variable.

La description vectorielle d'un glyphe est définie de la façon suivante :

Les descriptions vectorielles seront supposées normalisées de sorte que la ligne de base corresponde à l'ordonnée 0, que la hauteur de l'œil soit 1, et enfin que le glyphe soit collé à l'abscisse 0, sans dépassement vers les abscisses négatives.

Concrètement, la description vectorielle d'un glyphe est une liste de listes de listes de 2 flottants. À titre d'illustration, voici une description vectorielle d'un glyphe, composée de deux multi-lignes.

Python

Loading editor...

v = [ [ [ 0.25, 1.0 ], [ 0.25, -1.0 ], [ 0.0, -1.0 ] ], [ [ 0.25, 1.25 ] ] ]

La fonction dessiner_glyphe(v) (ajoutée, elle n'est pas dans le sujet) dessine une description vectorielle, avec la ligne de base et le haut de l'œil en pointillés :

Python
code masqué : pas besoin de le lire pour suivre, exécutez-le simplement
Q2

Dessiner ce glyphe. De quel caractère s'agit-il ?

Python

Loading editor...

Réponse

Partie II – Gestion de polices de caractères vectorielles

Une base de données stocke les informations liées aux polices de caractères dans 4 tables ou relations.

Voici un extrait du contenu de ces tables.

fidfnom
1Humane
2Garalde
3Réale
4Didone
5Mécane
6Linéale
......
pidpnomfid
1Centaur1
2Garamond2
3Times New Roman3
4Computer Modern4
.........
21Triangle6
.........
codecarcnom
65Alettre majuscule latine a
66Blettre majuscule latine b
.........
97alettre minuscule latine a
98blettre minuscule latine b
99clettre minuscule latine c
.........
gidcodepidgromangdesc
16520True[ [ [0, 0], [1, 2], [2, 0] ], [ [0.5, 1], [1.5, 1] ] ]
26520False[ [ [0, 0], [2, 2], [2, 0] ], [ [1, 1], [2, 1] ] ]
...............
5019721True[ [ [0, 0], [0.5, 1], [1, 0], [0, 0] ] ]
5029821True[ [ [0, 2], [0, 0], [1, 0.5], [0, 1] ] ]
5039921True[ [ [1, 1], [0, 0.5], [1, 0] ] ]
50410021True[ [ [1, 2], [1, 0], [0, 0.5], [1, 1] ] ]
...............
Dans la base fictive

Les numéros gid ne sont pas ceux de l'extrait ci-dessus, et la description gdesc est stockée sous forme de texte.

Q3

Proposer une requête en SQL sur cette base de données pour compter le nombre de glyphes en roman (cf. description précédente).

SQL

Loading editor...

Q4

Proposer une requête en SQL afin d'extraire la description vectorielle du caractère A dans la police nommée Helvetica en italique.

SQL

Loading editor...

Q5

Proposer une requête en SQL pour extraire les noms des familles qui disposent de polices et leur nombre de polices, classés par ordre alphabétique.

SQL

Loading editor...

Pour la suite, la requête de la question 4 est supposée paramétrée et encapsulée dans une fonction glyphe(c, p, r) qui renvoie la description vectorielle du caractère c dans la police p en roman ou italique selon le booléen r, de sorte que l'appel à glyphe("A", "Helvetica", False) répond à la question 4. (Ici, elle est déjà écrite dans la cellule ci-dessous : exécutez-la.)

Python
code masqué : pas besoin de le lire pour suivre, exécutez-le simplement

Partie III – Manipulation de descriptions vectorielles de glyphes

L'avantage de la description vectorielle de glyphes est qu'il est possible de réaliser des opérations sur les glyphes sans perte d'information. On peut réaliser simplement un agrandissement des glyphes, une déformation de glyphe pour en créer un nouveau etc. Cette partie propose des fonctions pour analyser et modifier des descriptions vectorielles.

Dans un premier temps, des fonctions sont créées pour extraire des informations sur des glyphes. Deux fonctions utilitaires sont implémentées.

Q6

Implémenter la fonction utilitaire points(v:[[[float]]])->[float] qui renvoie la liste des points qui apparaissent dans les multi-lignes de la description vectorielle v d'un glyphe.

v = [ [ [ 0, 0 ], [ 1, 1 ] ], [ [ 0, 1 ], [ 1, 0 ] ] ]
print(points(v))               # affiche la liste [ [ 0, 0 ], [ 1, 1 ], [ 0, 1 ], [ 1, 0 ] ]
Python

Loading editor...

def points(v:[[[float]]])->[float]:
    pass
Vérification : points
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).
Q7

Implémenter la fonction utilitaire dim(l:[[float]], n:int)->[float] qui renvoie la liste des éléments d'indice n (en commençant à 0) des sous listes de flottants, dont on supposera qu'ils existent toujours.

l = [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ], [ 7, 8 ] ]
print(dim(l, 1))                                   # affiche la liste [ 2, 4, 6, 8 ]
Python

Loading editor...

def dim(l:[[float]], n:int)->[float]:
    pass
Vérification : dim
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

On cherche à déterminer les dimensions (largeur et hauteur) d'un glyphe donné de manière à pouvoir les modifier par la suite si nécessaire.

Q8

Implémenter la fonction largeur(v:[[[float]]])->float qui renvoie la largeur de la description vectorielle v. Il faudra utiliser les fonctions utilitaires précédentes ainsi que les fonctions max et min de Python appliquées à des listes.

Python

Loading editor...

def largeur(v:[[[float]]])->float:
    pass
Vérification : largeur
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).
Q9

Implémenter la fonction obtention_largeur(police:str)->[float] qui renvoie une liste de largeurs pour toutes les lettres minuscules romanes et italiques (uniquement les 26 lettres non accentuées de a à z) de la police police dans l'ordre a roman, a italique, b roman, b italique...

Python

Loading editor...

def obtention_largeur(police:str)->[float]:
    pass
Vérification : obtention_largeur
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

On souhaite dériver automatiquement de nouvelles représentations vectorielles de glyphes à partir de représentations existantes.

Python permet de passer simplement des fonctions en paramètre d'autres fonctions. Par exemple, la fonction applique ci-après renvoie une nouvelle liste constituée en appliquant la fonction f à tous les éléments de la liste l.

Python

Loading editor...

def applique(f:callable, l:[])->[]:
    return [ f(i) for i in l ]

def incremente(i:int)->int:
    return i + 1

print(applique(incremente, [ 0, 5, 8 ]))       # affiche la liste [ 1, 6, 9 ]
Q10

En se basant sur l'exemple de la fonction applique, implémenter une fonction utilitaire transforme(f:callable, v:[[[float]]])->[[[float]]] qui prend en paramètres une fonction f, une description vectorielle v et qui renvoie une nouvelle description vectorielle construite à partir de v en appliquant la fonction f à chacun des points et en préservant la structure des multi-lignes. La fonction f passée en argument transforme un point en un autre point.

Python

Loading editor...

def transforme(f:callable, v:[[[float]]])->[[[float]]]:
    pass
Vérification : transforme
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

Soit la fonction zzz qui renvoie un nouveau point calculé de la façon suivante :

Python

Loading editor...

def zzz(p:[float])->[float]:
    return [ 0.5 * p[0], p[1] ]
Q11

Expliquer comment est modifiée une description vectorielle v par transforme(zzz, v). Préciser l'effet obtenu sur un glyphe.

Python

Loading editor...

Réponse
Q12

Implémenter la fonction penche(v:[[[float]]])->[[[float]]] qui renvoie une nouvelle description vectorielle correspondant à un glyphe penché vers la droite, obtenue en modifiant comme suit les coordonnées des points :

  • la nouvelle abscisse est ;
  • la nouvelle ordonnée reste .
Python

Loading editor...

def penche(v:[[[float]]])->[[[float]]]:
    pass
Vérification : penche
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

Partie IV – Rasterisation

La rasterisation est la transformation d'une image vectorielle en image matricielle. Cette opération est indispensable notamment pour afficher à l'écran une image vectorielle.

Dans cette partie, il s'agit d'analyser comment représenter le segment entre deux points d'une représentation vectorielle par des pixels encrés dans une image bitmap.

Le module PIL (Python Image Library) fournit le sous module Image :

Ici

im.show() ne fonctionne pas dans le navigateur : on utilise à la place la fonction montrer(im) ci-dessous (ajoutée, elle n'est pas dans le sujet), qui affiche l'image sous la cellule, avec la grille des pixels.

Python
code masqué : pas besoin de le lire pour suivre, exécutez-le simplement

Attention, dans le domaine graphique (images, impressions, écrans), et contrairement aux conventions mathématiques usuelles, le pixel (0, 0) est le coin en haut à gauche de l'image, l'axe des ordonnées est dirigé vers le bas. Ainsi, le code suivant crée une image bitmap rectangulaire 50 × 100 blanche avec deux barres horizontales formant un signe « = ».

Python

Loading editor...

from PIL import Image

im = Image.new("1", (50, 100), color=1)
for y in range(60, 65):
    for x in range(5, 45):
        im.putpixel((x, y), 0)
        im.putpixel((x, y-20), 0)
im.save("egal.png")
montrer(im, grille=False)

La fonction trace_quadrant_est implémente une partie de l'algorithme de tracé continu de segment proposé par Jack E. Bresenham en 1962.

Python

Loading editor...

from PIL import Image
from math import floor      # renvoie l'entier immédiatement inférieur

def trace_quadrant_est(im, p0, p1):
    x0, y0 = p0
    x1, y1 = p1
    dx, dy = x1-x0, y1-y0
    im.putpixel(p0, 0)
    for i in range(1, dx):
        p = (x0 + i, y0 + floor(0.5 + dy * i / dx))
        im.putpixel(p, 0)
    im.putpixel(p1, 0)

im = Image.new("1", (10, 10), color=1)
trace_quadrant_est(im, (0, 0), (6, 2))   # ligne 15
trace_quadrant_est(im, (9, 8), (1, 9))   # ligne 16
trace_quadrant_est(im, (3, 0), (5, 8))   # ligne 17
montrer(im)
Q13

Préciser les coordonnées des pixels de l'image encrés (pixels que l'on met en noir) par l'exécution de la ligne 15 ?

Réponse
Q14

Préciser les coordonnées des pixels de l'image encrés par l'exécution de la ligne 16 ? Indiquer d'où vient le problème rencontré. Proposer une assertion à mettre en début de fonction pour éviter ce problème.

Réponse
Q15

Préciser les coordonnées des pixels de l'image encrés par l'exécution de la ligne 17 ? Expliquer le problème rencontré et à quoi il est dû.

Réponse
Q16

En s'inspirant du code de la fonction trace_quadrant_est, implémenter une nouvelle fonction trace_quadrant_sud qui règle le problème précédent.

Python

Loading editor...

def trace_quadrant_sud(im, p0, p1):
    pass
Vérification : trace_quadrant_sud
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).
Q17

Implémenter la fonction trace_segment(im:Image, p0:(int), p1:(int)) qui trace un segment continu entre les pixels p0 et p1 sur l'image im supposée assez grande. Cette fonction devra opérer correctement si les deux points passés en arguments sont égaux.

Python

Loading editor...

def trace_segment(im, p0, p1):
    pass
Vérification : trace_segment
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

Partie V – Affichage de texte

La fonction trace_segment va maintenant permettre de tracer sur une page (comprendre une image matricielle) des glyphes à partir de leur description vectorielle.

Q18

Implémenter la fonction position(p:(float), pz:(int), taille:int)->(int) qui renvoie les coordonnées du point p (point d'un glyphe de coordonnées flottantes) en un point dans une page (pixel de coordonnées entières) de manière à ce que le point de la description vectorielle soit en position pz sur la page, et que l'œil de taille normalisée 1 du glyphe fasse taille pixels de hauteur. Prendre garde à la bonne orientation du glyphe sur la page. Vérifier que, pour la taille limite 1, l'œil du glyphe fait bien 1 pixel de hauteur.

Python

Loading editor...

def position(p, pz, taille):
    pass
Vérification : position
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).
Réponse
Q19

Implémenter la fonction affiche_car(page:Image, c:str, police:str, roman:bool, pz:(int), taille:int)->int qui affiche dans l'image page le caractère c dans la police police, en roman ou italique selon la valeur du booléen roman, et renvoie la largeur en pixel du glyphe affiché. Pour rappel, la fonction glyphe(c:str, police:str, roman:bool) charge la description vectorielle du caractère c dans la police police pour la variante roman.

Python

Loading editor...

def affiche_car(page, c, police, roman, pz, taille):
    pass

page = Image.new("1", (50, 50), color=1)
avance = affiche_car(page, "K", "Triangle", True, [ 10, 40 ], 16)
page.save("K.png")
montrer(page)
Vérification : affiche_car
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).
Q20

Implémenter la fonction affiche_mot(page:Image, mot:str, ic:int, police:str, roman:bool, pz:(int), taille:int)->int qui affiche la chaîne de caractères mot dans les mêmes conditions, chaque glyphe étant séparé du suivant par ic pixels, et renvoie la position du dernier pixel de la dernière lettre dans la page.

Python

Loading editor...

def affiche_mot(page, mot, ic, police, roman, pz, taille):
    pass

page = Image.new("1", (110, 50), color=1)
avance = affiche_mot(page, "Gödel...", 2, "Triangle", True, [ 10, 35 ], 13)
page.save("goedel.png")
montrer(page, grille=False)
Vérification : affiche_mot
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

De la même manière, on pourrait implémenter une fonction affiche_ligne(page:Image, ligne:[str], ic:int, im:int, police:str, roman:bool, pz:(int), taille:int) qui afficherait la liste de mots ligne en les séparant de im pixels.

Python

Loading editor...

Partie VI – Justification d'un paragraphe

L'objectif de cette dernière partie est d'afficher un paragraphe de manière harmonieuse en le justifiant, c'est-à-dire en alignant les mots sur les bords gauche et droit de la zone d'écriture de la page.

Le paragraphe à justifier est constitué d'une liste de mots (chaînes de caractères). La difficulté est de placer des espaces entre les mots et de découper la liste en sous-listes pour que les lignes soient équilibrées (pas de ligne avec beaucoup d'espaces à la fin ou entre les mots par exemple). Pour simplifier le problème, on considère que le paragraphe est constitué d'une liste lmots d'entiers correspondant aux longueurs de chaque mot du paragraphe dans l'ordre d'apparition des mots (lmots[i] correspond au nombre de caractères du mot d'indice i). On note L le nombre de caractères et espaces que peut contenir une ligne au maximum. Il faut au minimum un espace entre deux mots d'une même ligne, on suppose que cet espace minimal correspond à un caractère.

On propose dans un premier temps l'algorithme glouton suivant :

Python

Loading editor...

def glouton(Lmots:[int],L:int)->[[int]]:
    lignes=[]
    nligne=[]
    l=0
    for c in Lmots :
        if (c + l) > L:
            lignes.append(nligne)
            nligne=[c]
            l=c+1
        else:
            l=l+c+1
            nligne.append(c)
    lignes.append(nligne)
    return lignes

glouton([2, 4, 2, 6, 6], 10)
Q21

Expliquer en une ou deux phrases le principe de l'algorithme et pourquoi il est dit glouton.

Réponse

Cet algorithme fournit une solution mais qui n'est pas nécessairement optimale. Si on teste cet algorithme sur le paragraphe suivant extrait du lorem ipsum : ut enim ad minima veniam pour une longueur de ligne maximale L=10, le résultat obtenu est le découpage noté a). Si on utilise une méthode de programmation dynamique, on obtient le découpage noté b).

a) Découpage obtenu par l'algorithme gloutonb) Découpage obtenu par programmation dynamique
ut enim adut enim
minimaad minima
veniamveniam

Pour évaluer la pertinence du placement d'espaces et de retours à la ligne, on définit une fonction coût à minimiser pour que la répartition soit la plus harmonieuse possible.

Cette fonction coût correspond au nombre d'espaces disponibles sur une ligne élevé au carré, si on commence la ligne du mot i au mot j inclus sur cette même ligne :

Cette fonction prend la valeur lorsque la somme des longueurs des mots de i à j est supérieure à L (ce qui signifie qu'on ne peut pas placer les mots i à j sur une même ligne).

La fonction python suivante correspond à l'implémentation de cette fonction coût.

Python

Loading editor...

def cout(i:int,j:int,lmots:[int],L:int)->int:
    res=sum(lmots[i:j+1])+(j-i)
    if res>L:
        return float("inf")
    else:
        return (L-res)**2
Q22

Évaluer pour les deux découpages a) et b) de l'exemple, ce que renvoie la fonction coût pour chacune des lignes en précisant les indices i et j pour chaque ligne (lmots=[2,4,2,6,6]). Conclure sur l'algorithme qui donne la solution la plus harmonieuse en sommant les différents coûts par ligne pour le découpage a) puis pour le découpage b).

Python

Loading editor...

Réponse

La méthode de programmation dynamique consiste dans un premier temps à déterminer une équation de récurrence (équation de Bellman). Le problème peut être reformulé de la manière suivante :

Si on suppose connue la solution pour placer les mots jusqu'à un indice i, le nouveau problème consiste à placer correctement les changements de lignes du mot i jusqu'à la fin. La question est donc de savoir où placer le changement de ligne à partir du mot d'indice i, de manière à minimiser la fonction coût.

On note le problème du placement optimal de changement de ligne jusqu'à l'indice . L'équation de Bellman correspondante est alors :

Un algorithme récursif naïf correspondant à la résolution de ce problème est le suivant.

Python

Loading editor...

def algo_recursif(i:int,lmots:[int],L:int)->int:
    if i==len(lmots):
        return 0
    else:
        mini=float("inf")
        for j in range(i+1,len(lmots)+1):
            d=algo_recursif(j,lmots,L)+cout(i,j-1,lmots,L)
            if d<mini:
                mini=d
        return mini

algo_recursif(0, [2, 4, 2, 6, 6], 10)
Q23

Proposer une modification de la fonction algo_recursif pour rendre celle-ci plus efficace en introduisant une mémoïsation.

On définira la nouvelle fonction récursive progd_memo(i:int,lmots:[int],L:int,memo:{int:int}) avec la variable memo, dictionnaire initialisé en dehors de la fonction par memo={len(m):0}.

Python

Loading editor...

def progd_memo(i:int,lmots:[int],L:int,memo:{int:int})->int:
    pass
Vérification : progd_memo
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

On donne finalement une fonction utilisant la méthode de calcul de bas en haut. Cette fonction renvoie le coût optimal au problème de découpage de texte global de manière équivalente à la fonction progd_memo.

Python

Loading editor...

def progd_bashaut(lmots:[int],L:int)->int:
    M=[0]*(len(lmots)+1)
    for i in range(len(lmots)-1,-1,-1):
        mini,indi=float("inf"),-1
        for j in range(i+1,len(lmots)+1):
            d=M[j]+cout(i,j-1,lmots,L)
            if d<mini:
                mini,indi=d,j
        M[i]=mini
    return M[0]

progd_bashaut([2, 4, 2, 6, 6], 10)
Q24

Analyser, en fonction de nombres de mots, la complexité temporelle asymptotique associée à l'algorithme récursif naïf (fonction algo_recursif) ainsi qu'à l'algorithme de programmation dynamique de bas en haut (fonction progd_bashaut) et conclure sur l'intérêt de l'algorithme de programmation dynamique. On ne comptera que les opérations de type additions/soustractions. Il n'est pas attendu de développements mathématiques poussés, les résultats peuvent être donnés sans justification.

Réponse

On modifie légèrement la fonction progd_bashaut en ajoutant un argument t en plus des variables précédentes pour extraire les valeurs d'indices de découpe de lignes.

Python

Loading editor...

def progd_bashaut(lmots:[int],L:int,t:[int])->int:
    M=[0]*(len(lmots)+1)
    for i in range(len(lmots)-1,-1,-1):
        mini,indi=float("inf"),-1
        for j in range(i+1,len(lmots)+1):
            d=M[j]+cout(i,j-1,lmots,L)
            if d<mini:
                mini,indi=d,j
        t[i]=indi
        M[i]=mini
    return M[-1]

t = [0] * 5
progd_bashaut([2, 4, 2, 6, 6], 10, t)
t

t[i] est la valeur de l'indice dans la liste lmots correspondant au placement optimisé sur une même ligne des mots d'indice i jusqu'à t[i] exclus. Cette liste t est modifiée en place dans la fonction. Pour l'exemple étudié précédemment (cas b) ), on a ainsi obtenu la liste : t=[2, 3, 4, 4, 5].

On dispose de la liste des mots (chaînes de caractères cette fois-ci) notée mots.

La fonction lignes(mots:[str],t:[int],L:int)->[[str]] doit renvoyer une liste de listes de mots (chaque sous-liste correspond à une ligne) en fonction de la liste t donnée par l'algorithme. La fonction lignes(["Ut","enim","ad","minima","veniam"],[2,3,4,4,5],10) renvoie : [["Ut","enim"],["ad","minima"],["veniam"]].

De même, en prenant

t=[2, 3, 5, 5, 5, 6, 7, 9, 11, 11, 11]
L=15
mots=["Lorem","ipsum","dolor","sit","amet,","consectetur","adipiscing",
"elit.","Sed","non","risus."]

la fonction lignes(mots,t,L) renvoie :

[["Lorem","ipsum"],
["dolor","sit","amet,"],
["consectetur"],
["adipiscing"],
["elit.","Sed"],
["non","risus."]]
Q25

Proposer une implémentation de cette fonction lignes(mots:[str],t:[int],L:int).

Python

Loading editor...

def lignes(mots:[str],t:[int],L:int)->[[str]]:
    pass
Vérification : lignes
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

Il reste à écrire une fonction formatage(lignesdemots:[[str]],L:int) qui renvoie une chaîne de caractères correspondant à la justification du paragraphe à partir des listes de mots par ligne lignesdemots et de la longueur maximale L d'une ligne en termes de caractères et espaces. Les retours à la ligne seront représentés par le symbole "\n". Les espaces devront être répartis équitablement entre les mots pour que la justification se fasse bien entre la marge gauche et la marge droite (en respectant la longueur L maximale imposée).

Q26

Proposer une implémentation de cette fonction formatage(lignesdemots:[[str]],L:int)->str qui renvoie la chaîne de caractères justifiée.

Python

Loading editor...

def formatage(lignesdemots:[[str]],L:int)->str:
    pass
Vérification : formatage
Teste les fonctions que vous avez écrites (exécutez d'abord les blocs où elles sont définies).

Entrez le code donné en cours pour accéder à la solution :