steph1978 a écrit 3463 commentaires

Rien à voir avec hier, les deux parties en une grosse demie heure.

part 1

import sys

X = 1
C = 0
S = []
I = {20, 60, 100, 140, 180, 220}

def inc():
  global C
  C += 1
  if C in I:
    S.append(C*X)

for l in sys.stdin.read().splitlines():
  m, q = (l+" _").split(" ")[:2]
  if m == "noop":
    inc()
  else: # add
    inc()
    inc()
    X += int(q)

print(sum(S))

part 2

import sys

X = 1
C = 0
LCD = [["."]*40 for _ in range(6)]

def inc():
  global C
  (r,c) = divmod(C, 40)
  C+=1
  if c in [X, X-1, X+1]:
    LCD[r][c]="#"

for l in sys.stdin.read().splitlines():
  m, q = (l+" _").split(" ")[:2]
  if m == "noop":
    inc()
  else: # add
    inc()
    inc()
    X += int(q)

print("\n".join("".join(r) for r in LCD))

J'ai fait la première partie en AWK en une petite demie heure.
J'ai eu pas mal de chance car mes calculs étaient approximatifs mais suffisant pour le cas à un noeud.

En voyant la seconde partie, j'ai tout ré-écrit en python car j'y ai vu un truc récursif.
J'ai pigé assez vite qu'il fallait mieux faire toutes les étapes, case par case pour tous les neouds.
Ça donnait toujours le bon résultat pour le premier noeud mais pas pour le dernier.

J'ai mis vraiment beaucoup de temps à débugger en pas à pas et ajuster mes calculs. Plusieurs heures :(
Pour au final un code très impératif que j'aurai presque pu laisser en AWK.

Bref dur ce jour pour moi

part 1

BEGIN{P["0_0"]=1; Hx=Hy=Tx=Ty=0}
function abs(x) { return x>0?x:-x}
{
  print "==", Hx","Hy, ";", Tx","Ty, "==", $1, $2
  for(i=1;i<=$2;i++){
    if($1=="R") {Hx++}
    if($1=="L") {Hx--}
    if($1=="U") {Hy++}
    if($1=="D") {Hy--}
    dh = abs(Hx-Tx)  # tension horizontale
    dv = abs(Hy-Ty)  # tension vertivale
    if(dh>1 && $1=="R") {Tx++; if (dv>0) {Ty=Hy}}
    if(dh>1 && $1=="L") {Tx--; if (dv>0) {Ty=Hy}}
    if(dv>1 && $1=="U") {Ty++; if (dh>0) {Tx=Hx}}
    if(dv>1 && $1=="D") {Ty--; if (dh>0) {Tx=Hx}}
    P[Ty "_" Tx]=1
    print Hx, Hy, ";", "dh:"dh, "dv:"dv, "=>", Tx, Ty
  }
}
END{print length(P)}

part 2

import sys

rope = [(0,0) for _ in range(10)]
P = [{(0,0)} for _ in range(10) ]
D = {"R":(1,0),"L":(-1,0),"U":(0,1),"D":(0,-1)}

for l in sys.stdin.read().splitlines():
  M, q = l.split(" ")
  q = int(q)
  for k in range(q):
    (x,y) = rope[0]
    (dx,dy) = D[M]
    rope[0] = (x+dx, y+dy)
    for i in range(1,10):
      (Hx,Hy) = rope[i-1]
      (Tx,Ty) = rope[i]
      dh = Hx-Tx  # tension horizontale
      dv = Hy-Ty  # tension vertivale
      if (abs(dh)>1):
        Tx += 1 if dh > 0 else -1
        if (abs(dv)>0):
          Ty += 1 if dv > 0 else -1
      elif (abs(dv)>1):
        Ty += 1 if dv > 0 else -1
        if (abs(dh)>0):
          Tx += 1 if dh > 0 else -1
      P[i].add((Tx,Ty))
      rope[i] = (Tx,Ty)

print(*(len(p) for p in P))

Tu as eu une meilleure approche pour le première partie en effet. Il vaut mieux considérer les bords (N²⁾ que toute les position de la grille (N^3).
En pratique all va s'arrêter au premier False, ce qui fait que les chronos sont assez poche (0:33 pour les deux). Aussi parce que N est petit (N=99) et que lancer l'interpréteur est incompressible. Mais en théorie, c'est bien meilleur.

Même méthode pour les deux parties : un parcours de chaque position d'une matrice. Pour chaque position, regarder à gauche, à droite, en haut, en bas. Ça donne pas un code très beau mais ça marche.

part 1

import sys
L = list(list(map(int,s)) for s in sys.stdin.read().splitlines())
W = len(L[0]) ; H = len(L)
N=0
for i in range(H):
    for j in range(W):
        v = L[i][j]
        # look right
        r = all(L[i][k]<v for k in range(j+1, W))
        # look left
        l = all(L[i][k]<v for k in range(j))
        # look up
        u = all(L[k][j]<v for k in range(i))
        # look down
        d = all(L[k][j]<v for k in range(i+1,H))
        N += (r|l|u|d)
print(N, W*H)

part 2

Encore plus moche car le code à répéter quatre fois est plus long.

import sys
L = list(list(map(int,s)) for s in sys.stdin.read().splitlines())
W = len(L[0]) ; H = len(L)
S=0
for i in range(H):
    for j in range(W):
        v = L[i][j]
        # look right
        r = 0
        for k in range(j+1, W):
            r += 1
            if L[i][k]>=v:
                break
        # look left
        l = 0
        for k in range(j-1,-1,-1):
            l+=1
            if L[i][k]>=v:
                break
        # look up
        u = 0
        for k in range(i-1,-1,-1):
            u+=1
            if L[k][j]>=v:
                break
        # look down
        d = 0
        for k in range(i+1,H):
            d += 1
            if L[k][j]>=v:
                break
        S = max(S,r*l*u*d)
print(S)

Vivement que les lutins nous fournissent une carte pour aller quelque part.

Toi t'as envie de ressortir quelques algos de parcours de graphes :) Dijkstra sort de ce corps!

C'est vrai que rien n'empêche de repasser deux fois pas le mm endroit pour pousser l'exploration des répertoires. Mais en effet c'est tordu et je n'avais pas de raison de me protéger "à prirori" de ce cas de figure. Si je n'étais pas parvenu à passer le test et la première partie, j'aurai regardé d'un peu plus près pour voir si des commandes cd child ne se répetent pas.

n'allons pas prétendre que tout est devenu nickel en la matière.

Non en effet. Mais je pense que la balance a penché côté linux en terme de matériel supporté, en particulier quand tu veux prolonger un ordinateur qui a plus de 5 ans.

En fait vu la structure de l'input où il n'y a que de cd child et cd .. # parent, c'est nécessairement un parcours d'arbre en profondeur d'abord. Il n'y a pas d'autres représentations de la relation parent-enfants, genre cd /chemin/absolu en aléatoire.

Et puis je préfère faire un code simple, le valider sur l'exemple, voire cramer un essai, avant de compliquer le code.

En bon unixien

En bon unixien, un répertoire pèse en lui même 4096 octets, à ajouter à son contenu. Et un fichier est arrondi aux 4Ko supérieurs. Ça changerai sûrement la réponse. 😆

Comme le FS est parcourus "en profondeur d'abord" et dans l'ordre, pas besoin d'une structure de données trop compliquée type arbre, une simple liste suffit.

partie 1

BEGIN { LIMIT=100*1000 }
$2 == "ls" || $1 == "dir" { next}
$2 == "cd" && $3 == ".." { # on monte
    if (S[depth]<=LIMIT) {   # <= "at most" !!!!!!!!!
        R+=S[depth]
    }
    S[depth]=0   # ne pas oublier le reset du précédent cousin
    depth -= 1
}
$2 == "cd" && $3 != ".." { depth += 1; P[depth]=$3; }  # on descend
NF == 2 {  # fichier
    for (i=1;i<=depth;i++) {
        S[i]+=$1
    }
}
END { print R }

J'ai perdu au moins une demie heure sur le fait que j'ai interprété "at most" en "au moins" car j'imaginais chercher des trucs gros (on veut libérer de la place). Alors que c'est "au plus" ; GRRR ; Bien lire l'énoncée sans faire d'hypothèse !

partie 2

Pour cette partie où il faut trouver le dossier qui permet de libérer l'espace juste nécessaire pour dl la mise à jour, j'ai utilise un script de debug qui me liste les tailles de tous les répertoires. J'ai calculé à la main l'espace qu'il me faillait, et j'ai regardé dans la liste triée des tailles (| sort -n) celle qui était juste au dessus. Oui on a le droit de bidouiller pour l'AoC si ça permet d'aller plus vite à la solution.

transmettre un paramètre d'une requête à une autre

C'est en gros le principe du cookie. Et ce n'est pas sale :)

une imprimante non reconnue

Tu vis dans les années 90 ? Aujourd'hui le matériel de tout poil est mieux reconnu sous Linux que sous Wouinoui. En particulier les imprimantes. Tu branches l'USB et c'est fini. Winouin tu rien ne se passe, tu vas sur le site du constructeur, tu installes en admin une application de 80Mo, tu reboot.

Finalement une solution en AWK, pas si moche quand on a pas de "set".

BEGIN { W = 14 }
{
    for (i=1; i<=length($1); i++) {
        window = substr($1,i,W)
        # compare each char of window to all char of window
        S = 0  # to count match
        for (j=1; j<=W; j++) {
            for (k=1; k<=W; k++) {
                S+= (substr(window,j,1) == substr(window,k,1)) ? 1 : 0
            }
        }
        if (S == W) {  # if each char match only itsef
            print i + W - 1
            next  # finish
        }
    }
}

Je ne suis pas du tout satisfait par le fait de transformer à chaque fois un bout glissant de la chaîne d'entrée en un ensemble

Ma première solution était à base de deque et n'utilisait pas set. L'idée étant que si tu as dédoublonné la fenêtre précédente, et tu as un nouveau caractère, seul celui-ci peu créer un doublon. Donc au lieu de tout dédoublonner (set), tu dédoublonnes que par rapport à ce nouveau caractère.

Voici:

import sys
from collections import deque

dq = deque()
for (i,c) in enumerate(sys.stdin.read()):
    equals = list(filter(lambda x: c == x[1], enumerate(dq)))  # find duplicate
    assert len(equals)<2
    if len(equals)==1: # remove left part until a char equal to c, included
        for _ in range(equals[0][0]+1):
            dq.popleft()
    if len(dq) == 13: # if we have 13+1 distinct chars, we're good
        print(i+1)
        break
    dq.append(c)

Mais honnêtement, c'est bien plus compliqué pour pas grand chose.

Faudrait faire du profilage cpu et ram pour comparer mais sur la taille de mon input et avec la commande time, rien de visible. Et je crains que construire un set de 14 caractères ne soit pas plus coûteux que de manipuler la deque et et le filter.

ne peux pas installer de réseau social ni d'appli bancaire,

Je n'utilise que deux applications non disponible sur fdroid : ma banque et l'appli SNCF. J'utilise Aurora Store pour les DL et ça juste marche.

J'imagine qu'un fabriquant français pourrait fournir le mm mécanisme ainsi qu'une store à lui. J'imagine aussi qu'on pourrait persuader des entreprises françaises de mettre leur applications à dispo aussi sur ce store. Cela ne complique pas bcp le déploiement pour eux.

où tu dois paramétrer ton propre cloud pour synchroniser tes données, ça ne sert pas à grand-chose à la clientèle cible de Crosscall

Un constructeur pourrait proposer son cloud ou un cloud souverain.

Pas mieux

import sys
s = sys.stdin.read()
for i in range(14, len(s)):
    if len(set(s[i-14:i])) == 14:
        print(i)
        break

Mais c'est surtout une expérience utilisateur misérable

Question de goût. C'est pas parce que tu aime pas qu'il faut en dégoûter les autres.

Moi j'aime beaucoup (lineageos + fdroid), je trouve ça reposant. C'est fluide. Pas d'applications qui cherchent à te la mettre à l'envers. Un Firefox avec synchro de profile, un VLC pour les vidéos, un OSMAND pour la navigation offline. Un bonheur.

L'énoncé m'a fait tout de suite pensé à deque ; donc même soluce, en moins classieux

import sys
from collections import deque
# init data structure
S = list()
for _ in range(9):
    S.append(deque())
# parse initial positions
for _ in range(8):
    line = next(sys.stdin)
    for j in range(9):
        c = line[4*j+1]
        if c != " ":
            S[j].append(c)
next(sys.stdin)
next(sys.stdin)
# process
while line := sys.stdin.readline():
    _, q, _, f, _, t = line.strip().split(" ")
    for _ in range(int(q)):
        S[int(t)-1].appendleft(S[int(f)-1].popleft())
# print final positions
print("".join(s.popleft() for s in S))

Et une deque temporaire pour les CradeMover9001

import sys
from collections import deque
# init data structure
S = list()
for _ in range(9):
    S.append(deque())
# parse initial positions
for _ in range(8):
    line = next(sys.stdin)
    for j in range(9):
        c = line[4*j+1]
        if c != " ":
            S[j].append(c)
next(sys.stdin)
next(sys.stdin)
# process
while line := sys.stdin.readline():
    _, q, _, f, _, t = line.strip().split(" ")
    tmp = deque()
    for _ in range(int(q)):
        tmp.append(S[int(f)-1].popleft())
    for _ in range(int(q)):
        S[int(t)-1].appendleft(tmp.pop())
# print final positions
print("".join(s.popleft() for s in S))```

mais si c'est pour mettre du Android dedans, ce sera tous sauf souverain

On peut mettre du Android sans Google. Ça demande un peu de travail mais moins que de créer un OS from scratch et ça permet une certaine compatibilité.

Je ne sais pas si ce ne serait pas possible d'exhumer Firefox OS pour faire baisser le prix.

Fichier texte qui s’affiche ensuite dans vos mails, votre lecteur RSS ou votre nagivateur.

(tiens une faute de frappe)

Donc il écrit un gmi qui est gros est du md et il a une moulinette qui crée un HTML, un RSS, un mail et qui envoie tout ça par le canal qui va bien. C'est à peu près ma définition du SSG.

Merci pour ta vigilance vis à vis de ce lobby écologiste dont le but est de nous fourguer … heu … un changement complet de note modèle consumériste. Ça se vend ça ?

Nous attendons vivement tes analyses sur les lobbies de l'aggro alimentaire, de la chasse, des labo pharma, de l'industrie, du bâtiment.

Les instances invidious n'ont pas l'autoplay par défaut.

Télécharger les contenus en amont

Bof, si la vidéo fait 40 minutes et que tu t'aperçois au bout de 5 minutes que ça ne t'intéresse pas. Tu va DL 75% pour rien.

I think the solution should probably not involve git, local builds from the terminal, or CNAME configs to get a custom domain.

Bah si justement ! GitLab pages : un repo cloné d'une template Hugo ou autre et un enregistrement CNAME et un TXT, tu écris en Markdown et hop c'est publié. C'est bien aussi simple que les thèmes Wordpress et la mise en plage d'articles … et un enregistrement CNAME et un TXT pour avoir son domaine.

Et je ne prends que ça dans la liste des trucs à éviter énumérés par Mr Bernard avec laquelle je ne suis pas d'accord.

Heureusement la série "Post-Collapse Computing" me réconcilie avec le personnage.

Mais si son message est qu'il faut être activiste pour sauver le monde. J'admets et je les admire. Mais tout le monde n'a pas la foi de faire ça. Donc héberger des services internet pour des amis, leur refaire un vieux PC sous linux ou un smartphone sous lineage, c'est aussi apporter sa petite contribution.

Bref, Ploum a écrit un "static site generator".