alberic89 🐧 a écrit 169 commentaires

J'ai fait une PR qui a été acceptée, sudo est maintenant susceptible d'utiliser la langue de Molière pour se gausser de l'admin qui n'arrive pas à taper son mot de passe.
Je n'ai pas encore bien saisi le fonctionnement du processus de traduction, je ne sais donc pas s'il va falloir attendre une ou deux versions de développement pour que tout soit potentiellement traduit. (et ensuite la release stable, puis on passe ça dans les repos Debian testing, et avec un peu de chance dans cinq ans, ce sera bon pour le déploiement en stable)

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Les bricks de la Wii concernent surtout les utilisateurs qui « hackent » leur Wii en effectuant des manipulations non approuvées par Nitendo (installation de homebrews, patchs, etc).
Mais comme dit plus haut, un mauvais stockage prolongé peut détériorer physiquement la Wii.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

Je ne m'y connais pas trop en WiiU, plutôt en Wii. Je sais qu'il y avait eu des outils développés par la communauté pour dé-bricker les Wiis avec un minimum de matériel. J'avais vu par exemple qu'il était possible de remettre en état une Wii ayant connu un brick assez sévère avec une manette de GameCube ou un tapis de danse.
http://www.wii-info.fr/news-418-savemiifree-un-savemii-fait-maison.htm

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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 ?

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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 ?

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

[…] client lourd comme Thunderbird […]

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

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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.

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.

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

Il y a 10 sortes de gens dans le monde – ceux qui comprennent le ternaire, ceux qui ne le comprennent pas et ceux qui le confondent avec le binaire.