Mines Informatique Commune MP PC PSI 2023Sujet, corrigé et rapport du jury

ÉCOLE DES PONTS PARISTECH, ISAE-SUPAERO, ENSTA PARIS, TÉLÉCOM PARIS, MINES PARIS, MINES SAINT-ÉTIENNE, MINES NANCY, IMT ATLANTIQUE, ENSAE PARIS, CHIMIE PARISTECH - PSL.
Concours Mines-Télécom, Concours Centrale-Supélec (Cycle International).

CONCOURS 2023

ÉPREUVE D'INFORMATIQUE COMMUNE

Durée de l'épreuve : 2 heures

INFORMATIQUE COMMUNE

L'énoncé de cette épreuve comporte 8 pages de texte.

La typographie informatisée

Partie I - Préambule

• un caractère est un signe graphique d'un système d'écriture, par exemple le caractère latin a majuscule « A ». Le standard Unicode donne à chaque caractère un nom et un identifiant numérique, appelé point de code, que nous appellerons ci-après simplement code. Le code de « A » dans la représentation Unicode est 65 . La version 13.0 publiée en mars 2020 répertorie 143859 caractères couvrant 154 systèmes d'écriture, modernes ou historiques comme les hiéroglyphes;
• un glyphe est un dessin particulier représentant un caractère, par exemple pour le caractère latin a majuscule : A (roman) A (italique) A (caligraphié) A (gras), A (courrier)...
• une police de caractères est un ensemble coordonné de glyphes incluant différentes variantes (style roman ou italique, graisse...) et permettant de représenter un texte complet dans un système d'écriture. La police de ce document est Computer Modern, la police par défaut de AT_E X;
• une famille est un groupe de polices. La classification Vox-ATypI, proposée par Maximilien Vox en 1952 et adoptée par l'Association typographique internationale, contient 11 familles. La police Computer Modern fait partie de la famille Didone.
  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.

• un point p est repéré par ses coordonnées (abscisse, ordonnée) dans le plan orthonormé classique, et sera représenté par une liste de deux flottants ;
• une multi-ligne 1 est une séquence de points reliés par des segments, représentée par une liste de points, éventuellement restreinte à un seul point ;
• la description vectorielle v d'un glyphe est un ensemble non vide de multi-lignes, représenté par une liste de multi-lignes.
  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.

Partie II-Gestion de polices de caractères vectorielles

Partie III - Manipulation de descriptions vectorielles de glyphes

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

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

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 ]

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

• la nouvelle abscisse est x + 0.5∗y;
• la nouvelle ordonnée reste y.

Partic IV - Rasterisation

• im = Image.new (mode, size, color=0) alloue une nouvelle image matricielle, de type bitmap si mode vaut " 1 "; le tuple size donne la largeur et la hauteur de l'image en pixels; le paramètre facultatif color précise la couleur par défaut des pixels, en bitmap 1 pour blanc et 0 pour noir ;
• im.putpixel(( x, y ), 1) attribue la valeur 1 au pixel de coordonnées ( x, y ) de l'image im;
• im.save(nom_fichier) sauvegarde l'image dans un fichier dont on donne le nom;
• im.show() affiche l'image dans une fenêtre graphique.

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")

from PIL import Image
from math import floor # renvoie l'entier immédiatement inférieur
def trace_quadrant_est(im:img, p0:(int), p1:(int)):
    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))
trace_quadrant_est(im, (9, 8), (1, 9))
trace_quadrant_est(im, (3, 0), (5, 8))
im.show()

Partie V - Affichage de texte

from affiche import affiche_car
from PIL import Image
page = Image.new("1", (50, 50), color=1)
avance = affiche_car(page, "K", "Triangle", True, [ 10, 40 ], 16)
page.save("K.png")

◻ 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.

from affiche import affiche_mot
from PIL import Image
page = Image.new("1", (110, 50), color=1)
avance = affiche_mot(page, "Gödel...", 2, "Triangle", True, [ 10, 35 ], 13)
page.save("goedel.png")

Partie VI - Justification d'un paragraphe

Figure 1 - Illustration de la justification de paragraphe pour différentes polices

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

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

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

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]

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=[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."]

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

ut enim
ad minima
veniam

Fin de l'épreuve.