alberic89 🐧 a écrit 191 commentaires

Tu tapes sur le gens qui a implémenté ça parce que c'est pas localisé, et c'est toujours un peu plus triste de se faire insulter en anglais.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Apparemment, c'est possible avec Wine : https://appdb.winehq.org/objectManager.php?sClass=application&iId=6153
Mais je n'ai pas testé.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Je pense que mon commentaire plus haut aidera à clarifier ma situation.

Si je ne me trompe pas, tu parles d'une saisie automatique après que l'utilisateur utilise un raccourci clavier ou appuie sur un bouton. Mais je voudrais plutôt que le mot de passe soit rempli dès le chargement de la page, comme fait Firefox, mais en activant au cas-par-cas.

L'option dont tu parles se situe-t-elle dans l'extension de navigateur ou dans l'application de bureau ?

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Le cas d'usage est que sur certains sites se connecter est très pénible, il faut que je remplisse plusieurs formulaires pour pouvoir entrer après mon mot de passe. J'ai automatisé ça avec un petit script JavaScript, mais il faut encore que je clique sur la petite icone de keepassxc dans la barre de saisie pour qu'il accepte de remplir mon mot de passe. Je voulais outrepasser cette limitation et autoriser keepassxc à remplir mon mot de passe sur ce site sans mon accord.
À contrario, je ne veux pas être connecté automatiquement sur la plupart des sites que je visite, et donc ne souhaite pas que cette fonctionnalité soit active partout. Mais les mots de passe sont longs et je ne me souviens pas de tous, il faut donc qu'ils restent enregistrés et que je puisse les remplir d'un clic.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Je te recommande personnellement Thingiverse qui est très connu, ne contient que des modèles au minimum gratuits et parfois libres (à la différence de Cults où beaucoup de modèles sont payants). Tu peux les publier sous licence CC-BY (par exemple) sans problème.
Pour ce qui est du contenu, Thingiverse permet de publier tout type de fichiers 3D (FreeCAD inclus), les photos, les paramètres. Pour ce qui est de la documentation, tu peux mettre des fichiers txt ou bien directement écrire dans la description. Sont supportés les fichiers : STL, OBJ, THING, SCAD, JPG, TXT, amf, dae, 3ds, x3d, blend, ply, dxf, ai, svg, cdr, ps, eps, epsi, sch, brd, png, gif, doc, docx.

Ce que j'apprécie beaucoup avec Thingiverse, ce sont les remix. La très grande majorité des modèles sont autorisé à être re-mixés, et on se retrouve avec un objet de base et des tas d'améliorations spécifiques, des versions légèrement différente, etc. C'est pour moi l'un des grands points forts de Thingiverse.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Le Bio-Éthanol est bien moins cher que le GPL !

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Le WiFi est un peu bugué sur les pocketbook depuis koreader uniquement, ce qui rend difficile la mise à jour automatique, wallabag, wikipedia, etc.
Il y a pas mal d'issues dessus, mais je ne pourrais pas vraiment dire si ça fonctionne « correctement » pour moi, je n'utilise pas trop les services cloud et j'ai un proxy bloquant. Donc, je ne sais pas exactement ce qui ne marche pas quand je tente une mise à jour. La seule chose sûre, c'est que ça fonctionne depuis l'OS, j'ai déjà téléchargé des lires avec.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

J'ai testé Koreader sur une Touch Lux 5 de chez Pocketbook, et je recommande.

Ça rajoute une application dans laquelle on peut tout faire ou presque, ç'a vraiment vocation de remplacer tous les logiciels des fabricants plus ou moins foireux.

L'installation est très facile, il faut passer un peu de temps à tout configurer aux petits oignons pour avoir les raccourcis qui te plaisent et la mise en page que tu aimes, mais une fois que c'est fait, c'est super. Joli, paramétrable, extensible, avec une UI bien pensée pour l'usage.

Si ça peut te rassurer, tu peux toujours utiliser les applications « normales » pour ouvrir tes livres avec DRM ou emprunts à la bibliothèque.

Seul défaut, des problèmes pour se connecter au WiFi depuis l'application, mais c'est apparemment un problème récurrent chez les PocketBook.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Ce n'est en général aucune touche par défaut, il faut configurer une touche spéciale pour le faire (j'ai choisi personnellement la touche Arrêt. défil que je n'utilise jamais). La manière de la configurer dépend surement de ta distribution/ton bureau. Avec GNOME (Debian), c'est dans Paramètres > Clavier > Touche de Composition.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

On peut aussi utiliser Compose Key,a,e : æ

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Autre changement : le moteur WebKit d’Apple n’est plus obligatoire sur iOS. Google pourra par exemple proposer Chromium sur Chrome, avec des performances différentes de celles de Safari.

Ça veut dire que Mozilla pourra enfin sortir un Firefox avec Gecko sur iOS ?

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Nous avons identifié que le problème était thermique, lié à des condensateurs chimiques ayant séché avec le temps et perdant de leur capacité à basse température. Un coup de sèche-cheveux a permis de redémarrer l'ordinateur de la surface.

C'est marrant, j'ai eu le même problème avec une télévision ! Elle ne fonctionnait correctement que l'été, il fallait faire des manipulations complexes pour la faire démarrer à la mi-saison, et impossible d'en tirer quoi que ce soit en hiver.

Ç'a l'air d'être malheureusement d'être un problème assez répandu.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

[…] client lourd comme Thunderbird […]

Comment ça Thunderbird est « lourd » ??!!?!

C'est absolument faux !!! Il est simplement un peu packagé.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Heureusement, il y a toujours le pétulant Achille Talon de Greg pour remonter tout ça.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

La plupart des liseuses ont des écrans à encre électronique, dont pas de lumière bleue, pas de soucis !

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Le paquet deb a un problème de dépendance sur Debian 12, il faut le compiler soi-même, ou utiliser l'AppImage pour Xorg.

Mais sinon, j'approuve complètement.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Le jeu Battle Tanks (btanks) a aussi mis sa décoration de Noël !

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Il y avait eu aussi https://linuxfr.org/users/alberic89/liens/bloquons-le-demarchage-telephonique-par-gee

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Voici ma solution, elle est rapide, mais elle m'a pris beaucoup de temps pour une et une seule raison : dans la première partie, j'ai codé une fonction qui calcule le poids si on bougeait les pierres vers le nord (en fait l'est puisque j'ai renversé le puzzle, je préfère les lignes aux colonnes).
Dans ma deuxième partie, je me dis ; « Réutilisons gaiement cette fonction après avoir effectivement fait rouler les pierres ! » 😔

#!/bin/python3

from functools import cache

def rotate90(lines):
    columns = [""]*len(lines[0])
    for i in range(len(lines[0])):
        columns[i] = "".join(reversed([ _[i] for _ in lines ]))
    return columns

@cache
def getWeight(rang,nb):
    return sum(range(rang-nb+1,rang+1))

@cache
def getLoad(line):
    count = 0
    total = 0
    for i, _ in enumerate(line):
        if _ == "#":
            total += getWeight(i,count)
            count = 0
        elif _ == "O":
            count += 1
    total += getWeight(len(line),count)
    return total

@cache
def getActualLoad(line):
    total = 0
    for i, _ in enumerate(line):
        if _ == "O":
            total += i+1
    return total

@cache
def fallLine(line):
    count = 0
    result = ""
    for i, _ in enumerate(line):
        if _ == "#":
            while len(result) < i - count:
                result += "."
            result += "O"*count + "#"
            count = 0
        elif _ == "O":
            count += 1
    while len(result) < len(line) - count :
        result += "."
    result += "O"*count
    return result

def cycle(puzzle,step):
    if step == 0:
        return puzzle, sum([getActualLoad(_) for _ in rotate90(puzzle)])
    return cycle([fallLine(_) for _ in rotate90(puzzle)],step-1)

def solve1(puzzle,testing=False):
    s=0
    s = sum([getLoad(_) for _ in rotate90(puzzle)])
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    pastresult = []
    now = puzzle
    pastresult.append(now)
    i=1
    while True:
        now, r = cycle(now,4)
        if now in pastresult:
            i = pastresult.index(now)
            tosum = ((1000000000 - i ) % (len(pastresult) - i)) + i
            s = sum([getActualLoad(_) for _ in rotate90(pastresult[tosum])])
            break
        pastresult.append(now)
        i+= 1
    if testing:
        print(s)
    return s

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Ce problème aurait dû être simple. Mais sinon ce ne serait pas un problème.

J'ai mis bien du temps à comprendre que je ne pouvais construire une liste vide de 256 listes vides juste avec [[],]*256 car alors toutes les listes sont liées, et la modification d'une seule entraine la modification de toutes les autres. Sigh. Moi qui espérais pouvoir rattraper mon léger retard, c'est mal parti, et ce n'est pas ce week-end que ça va s'arranger.

Un code néanmoins simple, et je l'espère facile à comprendre :

#!/bin/python3

def asciiHash(word):
    r = 0
    for l in word:
        r = ((r + ord(l)) * 17) % 256
    return r

def getPower(box):
    r = 0
    for i,b in enumerate(box):
        for index,lens in enumerate(b):
            r += lens[1]*(index+1)*(i+1)
    return r

def getEmptyList(nb):
    return [[] for _ in range(nb)]

def focusingPower(sequence):
    box = getEmptyList(256)
    for s in sequence:
        if s[-1] == "-":
            for index, lens in enumerate(box[asciiHash(s[:-1])]):
                if lens[0] == s[:-1]:
                    box[asciiHash(s[:-1])].remove(lens)
                    break
        else:
            c = False
            for index, lens in enumerate(box[asciiHash(s.split("=")[0])]):
                if lens[0] == s.split("=")[0]:
                    box[asciiHash(s.split("=")[0])][index] = (s.split("=")[0], int(s.split("=")[1]))
                    c = True
                    break
            if not c:
                box[asciiHash(s.split("=")[0])].append((s.split("=")[0], int(s.split("=")[1])))
    return getPower(box)

def solve1(puzzle,testing=False):
    s=0
    s = sum([asciiHash(_) for _ in puzzle[0].split(",")])
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    s = focusingPower(puzzle[0].split(","))
    if testing:
        print(s)
    return s

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Aujourd'hui, je considère ma carte comme une grille avec 0,0 en haut à gauche, puis je cherche les lignes/colonnes vides, puis l'emplacement des galaxies que j'associe par paires.

Je cherche ensuite la distance entre les paires de galaxies, et ajoute à ces distances le nombre de lignes/colonnes vides comprises entre les deux galaxies multiplié par un facteur (1 pour la 1^er partie, 1000000-1 pour la 2^e ).

Le code :

#!/bin/python3

def getVoid(puzzle):
    void_lines = []
    for i, line in enumerate(puzzle):
        if all([e == "." for e in line]):
            void_lines.append(i)
    void_columns = []
    for col in range(len(puzzle[0])):
        if all([l[col] == "." for l in puzzle]):
            void_columns.append(col)
    return void_lines, void_columns

def getGalaxies(puzzle):
    galaxies = []
    for i, line in enumerate(puzzle):
        for j, space in enumerate(line):
            if space == "#":
                galaxies.append((j,i))
    return galaxies

def getPairs(galaxies):
    pairs = []
    for i in range(len(galaxies)):
        for p in range(i):
            pairs.append((galaxies[i],galaxies[p]))
    return pairs

def getSpaceBetween(pair, void_lines, void_columns, space_void):
    spacex = abs(pair[1][0] - pair[0][0])
    spacex += sum([space_void if i in void_columns else 0 for i in range(min([pair[0][0],pair[1][0]]),max(pair[0][0],pair[1][0]))])
    spacey = abs(pair[1][1] - pair[0][1])
    spacey += sum([space_void if i in void_lines else 0 for i in range(min([pair[0][1],pair[1][1]]),max(pair[0][1],pair[1][1]))])
    return spacex+spacey

def solve1(puzzle,testing=False):
    s=0
    void_lines, void_columns = getVoid(puzzle)
    galaxies = getGalaxies(puzzle)
    pairs = getPairs(galaxies)
    for p in pairs:
        s += getSpaceBetween(p,void_lines,void_columns,1)
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    void_lines, void_columns = getVoid(puzzle)
    galaxies = getGalaxies(puzzle)
    pairs = getPairs(galaxies)
    for p in pairs:
        s += getSpaceBetween(p,void_lines,void_columns,1000000-1)
    if testing:
        print(s)
    return s

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Quand j'ai vu que l'énoncé nous demandait de définir une boucle fermée, j'ai tout de suite senti qu'on allait devoir en calculer l'aire dans la partie suivante.
Je ne me suis pas trompé.
Dans la partie une, une récursion sur toute la boucle suffit (en augmentant la limite de récursion).
Ma logique pour la partie deux est que certains motifs nous font entrer ou sortir de la boucle, il suffit de les repérer en parcourant toute la carte.
Et beaucoup de gestion d'erreur pour repérer les erreurs de logique quand on code ou pour ne pas avoir à tester les longueurs des chaînes.
Voici mon code :

#!/bin/python3
import sys

sys.setrecursionlimit(10000)

def getStart(puzzle):
    for i,l in enumerate(puzzle):
        for j,p in enumerate(l):
            if p == "S":
                return [i,j]

def initLoop(puzzle,countpipes=True,get_connections=False):
    start = getStart(puzzle)
    direction = ""
    connections = ""
    go_away = [0,0]
    try:
        if puzzle[start[0]-1][start[1]] in ["F","7","|"]:
            direction = "H"
            connections += direction
            go_away = [-1,0]

    except IndexError:
        pass
    try:
        if puzzle[start[0]][start[1]-1] in ["F","L","-"]:
            direction = "G"
            connections += direction
            go_away = [0,-1]
    except IndexError:
        pass
    try:
        if puzzle[start[0]][start[1]+1] in ["J","7","-"]:
            direction = "D"
            connections += direction
            go_away = [0,1]
    except IndexError:
        pass
    try:
        if puzzle[start[0]+1][start[1]] in ["J","L","|"]:
            direction = "B"
            connections += direction
            go_away = [1,0]
    except IndexError:
        pass
    start = [start[0]+go_away[0],start[1]+go_away[1]]
    if get_connections:
        return connections
    if countpipes:
        pipes.append(start)
    return round((browseLoop(puzzle, start, direction,countpipes)+1)/2)

def browseLoop(puzzle, start, direction, countpipes=True):
    here = puzzle[start[0]][start[1]]
    if here == "-":
        if direction == "D":
            start = [start[0],start[1]+1]
        elif direction == "G":
            start = [start[0],start[1]-1]
        else:
            raise ValueError
    elif here == "|":
        if direction == "H":
            start = [start[0]-1,start[1]]
        elif direction == "B":
            start = [start[0]+1,start[1]]
        else:
            raise ValueError
    elif here == "L":
        if direction == "B":
            start = [start[0],start[1]+1]
            direction = "D"
        elif direction == "G":
            start = [start[0]-1,start[1]]
            direction = "H"
        else:
            raise ValueError
    elif here == "F":
        if direction == "H":
            start = [start[0],start[1]+1]
            direction = "D"
        elif direction == "G":
            start = [start[0]+1,start[1]]
            direction = "B"
        else:
            raise ValueError
    elif here == "7":
        if direction == "D":
            start = [start[0]+1,start[1]]
            direction = "B"
        elif direction == "H":
            start = [start[0],start[1]-1]
            direction = "G"
        else:
            raise ValueError
    elif here == "J":
        if direction == "D":
            start = [start[0]-1,start[1]]
            direction = "H"
        elif direction == "B":
            start = [start[0],start[1]-1]
            direction = "G"
        else:
            raise ValueError
    else:
        raise ValueError
    if countpipes:
        pipes.append(start)
    if puzzle[start[0]][start[1]] == "S":
        return 1
    else:
        return browseLoop(puzzle,start,direction)+1

def areConnected(somepipes):
    if somepipes[0] not in ["F","L"]:
        return False
    if not all([i=="-" for i in somepipes[1:-1]]):
        return False
    if somepipes[-1] not in ["7","J"]:
        return False
    if somepipes[0] == "F" and somepipes[-1] == "J":
        return True
    if somepipes[0] == "L" and somepipes[-1] == "7":
        return True
    return False

def floodPipes(puzzle):
    initLoop(puzzle,countpipes=True)
    connections = initLoop(puzzle,get_connections=True)
    start = getStart(puzzle)
    restart = ""
    if all([c in "HB" for c in connections]):
        restart = "|"
    elif all([c in "GD" for c in connections]):
        restart = "-"
    elif all([c in "HD" for c in connections]):
        restart = "L"
    elif all([c in "BD" for c in connections]):
        restart = "F"
    elif all([c in "HG" for c in connections]):
        restart = "J"
    elif all([c in "BG" for c in connections]):
        restart = "7"
    else:
        print(connections)
        raise ValueError

    puzzle[start[0]] = puzzle[start[0]].replace("S",restart)
    inloop = False
    surface = 0
    for i, l in enumerate(puzzle):
        inloop == False
        for j, p in enumerate(l):
            if [i,j] in pipes:
                if puzzle[i][j] == "|":
                    inloop = not inloop
                elif puzzle[i][j] in ["J","7"]:
                    r = puzzle[i][j]
                    iterator = j
                    try:
                        while puzzle[i][iterator] not in ["F","L"]:
                            iterator -= 1
                            r = puzzle[i][iterator] + r
                    except IndexError:
                        pass
                    if areConnected(r):
                        inloop = not inloop

            elif inloop:
                surface += 1

    return surface

def solve1(puzzle,testing=False):
    s=0
    s = initLoop(puzzle)
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    global pipes
    pipes = []
    s = 0
    s = floodPipes(puzzle)
    if testing:
        print(s)
    return s

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Je ne connaissais pas moi-même la fonction all, j'ai fait au plus simple avec une fonction codée par mes soins. Mais c'est vrai qu'on pourrait gagner en efficacité.

Et avec des nombres négatifs, il doit sûrement y avoir des nombres négatifs, ce qui explique que sum retourne 0.

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Un exercice étonnamment simple aujourd'hui, mais les explications me semblent un peu embrouillées, est-ce fait exprès ?
Quoi qu'il en soit, voici mon code :

def parse_input(puzzle):
    r = []
    for p in puzzle:
        if p == "":
            continue
        p = p.split()
        p.reverse()
        r.append([int(i) for i in p])
    return r

def parse_input_not_reversed(puzzle):
    r = []
    for p in puzzle:
        if p == "":
            continue
        r.append([int(i) for i in p.split()])
    return r

def are_null(suite):
    for n in suite:
        if n != 0:
            return False
    return True

def find_number(suite):
    suivant = []
    for i,n in enumerate(suite[:-1]):
        suivant.append(n-suite[i+1])
    if are_null(suivant):
        return suite[0]
    else:
        return find_number(suivant)+suite[0]

def solve1(puzzle,testing=False):
    s=0
    for l in parse_input(puzzle):
        s += find_number(l)
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    for l in parse_input_not_reversed(puzzle):
        s += find_number(l)
    if testing:
        print(s)
    return s

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès

Ma solution aurait pu être mieux optimisée pour la lisibilité et la redondance, mais elle fonctionne. Je définis une classe pour les nœuds, surcharge quelques opérateurs, prétraite quelques données, et trouve le ppcm en utilisant le module math de Python.

#!/bin/python3

from math import lcm

class Nodon:
    def __init__(self,name,left,right):
        self.name = name
        self.right = right
        self.left = left

    def __repr__(self):
        return self.name

    def __eq__(self,stringnode):
        if self.name == stringnode:
            return True
        return False

    def endswith(self,letter):
        if self.name[2] == letter:
            return True
        return False

    def go(self,direction):
        if direction == "R":
            return self.right
        if direction == "L":
            return self.left
        raise ValueError


def parse_node(puzzle):
    direction = puzzle[0]
    nodes = []
    for line in puzzle[1:]:
        if line == "":
            continue
        nodes.append(Nodon(line[:3],line[7:10],line[12:15]))
    return direction, nodes

def run(direction, nodes):
    now = nodes[nodes.index("AAA")]
    nb = 0
    while now != "ZZZ":
        for d in direction:
            now = now.go(d)
            nb += 1
            if now == "ZZZ":
                break
    return nb

def nodesendswith(nodes, l):
    for n in nodes:
        if n.endswith(l) == False:
            return False
    return True

def beforerun(nodes):
    for n in nodes:
        n.right = nodes[nodes.index(n.right)]
        n.left = nodes[nodes.index(n.left)]
    return nodes

def runboth(direction, nodes):
    now = []
    for n in nodes:
        if n.endswith("A"):
            now.append(n)
    nb = 0
    ends = []
    while len(now) != 0:
        for d in direction:
            nb += 1
            for i in range(len(now)):
                now[i] = now[i].go(d)
                if now[i].endswith("Z"):
                    ends.append(nb)
                    now[i] = None
            for i in range(now.count(None)):
                now.remove(None)
            if len(now) == 0:
                break
    return lcm(*ends)

def solve1(puzzle,testing=False):
    s=0
    d, nodes = parse_node(puzzle)
    s = run(d, tuple(beforerun(nodes)))
    if testing:
        print(s)
    return s

def solve2(puzzle,testing=False):
    s = 0
    d, nodes = parse_node(puzzle)
    s = runboth(d, tuple(beforerun(nodes)))
    if testing:
        print(s)
    return s

test1 = """RL

AAA = (BBB, CCC)
BBB = (DDD, EEE)
CCC = (ZZZ, GGG)
DDD = (DDD, DDD)
EEE = (EEE, EEE)
GGG = (GGG, GGG)
ZZZ = (ZZZ, ZZZ)
"""
result1 = 2
test2 = """LR

11A = (11B, XXX)
11B = (XXX, 11Z)
11Z = (11B, XXX)
22A = (22B, XXX)
22B = (22C, 22C)
22C = (22Z, 22Z)
22Z = (22B, 22B)
XXX = (XXX, XXX)
"""
result2 = 6

# for cli invocation

def solve(short=False,one=True,two=True):

    s1, s2 = False , False

    if one:
        print("----Part 1----")
        if short == False:
            if solve1(test1.split("\n"),testing=True) != result1:
                print("Not working.")
                return False
            else :
                print("Maybe working?")
        with open("input.txt",'r') as file:
            lines = file.read().split("\n")
            s1 = solve1(lines)
            print(s1)

    if two:
        print("----Part 2----")
        if short == False:
            if solve2(test2.split("\n"),testing=True) != result2:
                print("Not working.")
                return False
            else :
                print("Maybe working?")
        with open("input.txt",'r') as file:
            lines = file.read().split("\n")
            s2 = solve2(lines)
            print(s2)

    return s1, s2

if __name__ == "__main__":

    from sys import argv

    s = False
    one = True
    two = True

    if len(argv) >= 2:

        if "-s" in argv or "--summary" in argv or "--short" in argv:
            s = True
        if "1" in argv:
            two = False
            one = True
        elif "2" in argv:
            one = False
            two = True
        if "2" in argv:
            two = True

    solve(short=s,one=one,two=two)

L'informatique n'est pas une science exacte, on n'est jamais à l'abri d'un succès