Gil Cot ✔ a écrit 5730 commentaires

Brave et merci pour cette release. La d´pêche viendra quand ça viendra.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

On essaye d’entrainer les modèles avec les variables les plus pertinentes possibles (par exemple, ayant les adresses de messagerie utilisées par les allocataires, son usage n’apporte à priori rien je pense…) Dans le doute, on suppose que tout ce qui est disponible est utilisé, mais il faut préciser que ça reste une supposition (et dire pourquoi on fait cette hypothèse) même si beaucoup de gens prendront cela pour argent comptant malheureusement.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Ça fait un bout de temps que des services qui se respectent n'utilisent plus de numéros masqués… Mais dans les deux cas ce sera un numéro inconnu du répertoire :-)
Je pense que pour une vraie urgence et tout motif légitime, les gens n'hésitent pas à laisser un message (sauf pour Tanguy), enfin je pense (et c'est en tout cas ce que j'ai expérimenté)

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Dans le cas présent on ne peut le prouver …sauf si les coupables avouent avoir eu l'adresse suite à un harcèlement. Et puis je peux bien me tromper (véridique : je ne connais ni mon numéro ni mon adresse postale par cœur)

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Conformément à la loi, j'annonce que l'appel est enregistré ; et je déclenche l'enregistrement pour les numéros inconnus (qui risquent d'être des démarcheurs.)
D'autres sont plus radicaux en rejetant automatiquement les numéros inconnus. Je ne sais pas si c'est mieux.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Au final tu lui as quand même donné ton adresse électronique.

Faut probablement prévoir une adresse jetable pour le pot-au-miel

Sinon, ce que tu dis de la justice et de la police indique pourquoi les citoyens lambdas n'ont pas confiance dans le système …qui ne se semble avoir rien à faire du petit peuple.

Pour bloctel, je continue à penser que c'est la manie française de problèmes à l'envers… On devrait donc plutôt l'autorisation d'être sollicité, et puis je ne vois pas pourquoi des gens à qui on n'a pas communiqué notre numéro nous appelle (déjà comment ont-ils eu le numéro ? ça me pose souci)

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Et oui, j'entends ceux du fond dire que le KornShell c'est plus mieux

Promis, on va pas refaire la discussion
Encore que la mode c'est pas de dire que Zsh est plus plus mieux ?

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Outre les questions de licence, les écoles se demandent qui elles évaluent vraiment…
https://academia.stackexchange.com/questions/191643/how-should-a-faculty-deal-with-the-problem-of-artificial-intelligence-ai-gener

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Y en a qui vieillissent mal bien …en exploitants nouveaux
https://www.commitstrip.com/fr/2022/12/09/a-whole-new-world/?

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Merci, je me note pour le film (la liste commence à devenir longue et le temps ost toujours aussi rare pauvre de moi)
Faut que je ressorte les VHS qui prennent la poussière, si ça se trouve c'est dans les trucs enregistrés pour plus tard et jamais vu…

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

C'est + de tracasseries (dont l'utilité n'est pas démontré) pour se faire vérifier
C'est + de facilité pour les gens qui ont accès à ton tél
C'est + d'emmerdes potentielles quand tu changeras de numéro ou de tél

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Il ne faut donc plus parler de Services Publics parce-que la seule chose que ça devrait maximiser, par essence, c'est le bonheur de la Collectivité.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Pourquoi mettre des moyens pour récupérer par exemple le manque à gagner du à l'évasion fiscale, quand on peut dépenser presque autant (ou plus ?) pour taper sur les "sans dents"  ? Et puis politiquement, c'est plus facile de s'acharner sur la masse pour montrer qu'on fait des choses que de se concentrer sur la minorité qui pose le plus de souci mais est moins vue de la foule. (soit ils ne connaissent pas Pareto et sont incompétents, soit ils savet bien et c'est de la manipulation)

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Excellent ! J'étais passé à côté de ça. Merci.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Je croise de temps en temps des serveurs qui n'ont que more (il ne s'agit bien entendu pas de distributions GNU/Linux qui installent et paramètrent par défaut less on s'entend.) Mais le problème ne se pose pas pour moi vu que offpunk est sur un poste perso que je contrôle. Ceci dit, j'ai croisé pas mal de gens qui ne juraient que par most. De mon côté, quand vim est installé sur une machine, j'ai tendance à remplacer (en usage interactif) less par view héhé.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Arf. Vivement que la recherche sur linuxfr refonctionne pour nous autres qui avons alzeimer :(

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

ou old school :)

def solve(StacksList, lines, step=1):
    for CranesCount, StackStart, StackDest in lines:
        StacksList[StackDest] += StacksList[StackStart][-CranesCount:][::step]
        StacksList[StackStart] = StacksList[StackStart][:-CranesCount]

    return "".join(s[-1] for s in StacksList)


data, lines = open("./input").read().split("\n\n")
StacksList = [
    "".join(column).rstrip()
    for i, column in enumerate(zip(*data.splitlines()[-2::-1]))
    if i % 4 == 1
]
lines = [
    (int(line[1]), int(line[3]) - 1, int(line[5]) - 1)
    for line in map(str.split, lines.splitlines())
]

print(solve(StacksList.copy(), lines, -1))
print(solve(StacksList.copy(), lines))

pas classieux mais ça a fait le job.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Pour la seconde partie ce fut un peu plus tricky car il faut trouver un moyen de comparer deux listes ou tableaux (première idée qui m'est venue.) J'ai initialement pensé à faire appel à dc mais c'est plutôt cryptique en plus d'être lent.
Finalement, on peut partir sur la dernière piste précédemment évoquée.

#!/bin/sh
# $1: input file

for c in 'comm' 'grep' 'seq' 'test'
do
    if ! command -v "$c" >/dev/null
    then
        echo "Error: command '$c' not found" >&2
        exit 3
    fi
done

if test -z "$1"
then
    echo "Please call me with an input file..." >&2
    exit 1
fi

if grep -Eqsv '^[0-9]+-[0-9]+,[0-9]+-[0-9]+$' "$1"
then
    echo "Found invalid line, check the file!" >&2
    exit 2
fi
_if="$1"

# First or Second elves in paire
# Start or End of section number
_s1=$( mktemp ) # 1st range sections list
_s2=$( mktemp ) # 2nd range sections list
_oc=0 # Overlap Counter
while IFS='-,' read -r _fs _fe _ss _se <&3
do
    seq $_fs $_fe >"$_s1"
    seq $_ss $_se >"$_s2"
    if test -n "$( comm -12 "$_s1" "$_s2" )"
    then
        _oc=$(( _oc + 1 ))
    fi
done 3<"$_if"
rm "$_s1" "$_s2"
echo "$_oc"

Il est à noter que, comme pour pierre-feuille-ciseau, il est possible d'utiliser l'évaluation arithmétique du shell.

_oc=0 # all Overlap Counter
while IFS='-,' read -r _fs _fe _ss _se <&3
do
    _oc=$(( _oc + !( (_ss>_fe) || (_fs>_se) ) ))
done 3<"$_if"
echo "$_oc"

Maintenant paye ton moins.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Je ne résiste pas à la réintroduction de split juste pour faire plus aisément la validation du fichier en entrée. Par contre, pas de commande connue qui nous serait utile dans la résolution… Du coup on peut sortir son langage de scripting favori, bien la chose ne soit pas insurmontable malgré l'absence de tableau/liste en POSIX shell (je sais, il y a set qui est très contraignant comparé aux tableaux dans (k|ba|z)sh si on veut rester dans du shell.)

#!/bin/sh
# $1: input file
# $2: split prefix

for c in 'cut' 'grep' 'tail' 'test'
do
    if ! command -v "$c" >/dev/null
    then
        echo "Error: command '$c' not found" >&2
        exit 3
    fi
done

if test -z "$1"
then
    echo "Please call me with an input file..." >&2
    exit 1
fi
_if="$1"

_sp=${2:-x} # Split Prefix
split -p '^( *[0-9])* *$' -a 1 "$_if" "$_sp" || exit 4

_bf="Found invalid line, check the file!" # Bad File message
if test $( ls -1 "$_sp"? | wc -l ) -ne 3
then
    echo "$_bf a" >&2
    exit 2
fi
if grep -Eqsv '^( *\[[A-Z]\])+ *$' "$_sp"a
then
    echo "$_bf b" >&2
    exit 2
fi
if tail -n+2 "$_sp"c | grep -Eqsv '^move [0-9]+ from [1-9] to [1-9]$'
then
    echo "$_bf c" >&2
    exit 2
fi
unset _bf

_nc=0 # Number of stacks/Columns
for i in $( cat "$_sp"b )
do
    _nc=$i
done

_cc=2 # Column Counter
_sl='' # Stacks List
while test $_nc -ne 0
do
    _sl="$_sl $( cut -c "$_cc" "$_sp"a | tr -d ' \n' )"
    _nc=$(( _nc - 1 ))
    _cc=$(( _cc + 4 ))
done
echo "$_sl" #debug

# Stack Stard
# Stack End
# Cranes Count
# trashed Word #
tail -n +2 "${_sp}c" | while read -r _w1 _cc _w2 _ss _w3 _se
do
    #echo "$_ss→$_se:" #debug
    while test $_cc -ne 0
    do
        _nl='' # New List
        _nc=1 # New Counter
        _cm='' # Crane Moved
        for j in $_sl
        do
            if test $_nc -ne $_ss
            then
                _nl="$_nl $j"
            else
                _cm=$( echo "$j" | cut -c 1 )
                if test ${#j} -ne 1
                then
                    _nl="$_nl $( echo "$j" | cut -c 2- )"
                else
                    _nl="$_nl -"
                fi
            fi
            _nc=$(( _nc + 1 ))
        done
        _sl=$_nl
        _nl='' # New List
        _nc=1 # New Counter
        for k in $_sl
        do
            if test $_nc -ne $_se
            then
                _nl="$_nl $k"
            else
                if test $k = '-'
                then
                    _nl="$_nl $_cm"
                else
                    _nl="$_nl $_cm$k"
                fi
            fi
            _nc=$(( _nc + 1 ))
        done
        _sl=$_nl
        _cc=$(( _cc - 1 ))
    done
    echo "$_sl"
done

Bien, le tube crée un processus fils avec des variables qui lui sont locales… (i.e. la variable globale $_sl n'est pas modifiée…) Il y a des solutions à cela, mais c'est un plaisir de suivre le travail de la grue avec un truc vite fait d'une part

 NZ DCM P
 DNZ CM P
 - CM ZNDP
 MC - ZNDP
 C M ZNDP

…et s'il fallait y passer du temps (plus d'un quart d'heure) et de l'énergie d'autre part, on pouvait directement partir sur un langage de programmation.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

La seconde partie m'a fait pensé à split pour les groupes de trois… Mais bon, ça fait pléthore de fichiers à gérer ensuite, et puis l'adaptation de la solution précédente n'est pas vraiment difficile (le truc en sus est d'arriver à compter …modulo trois.)

#!/bin/sh
# $1: input file

for c in 'cat' 'fold' 'grep' 'sort' 'test'
do
    if ! command -v "$c" >/dev/null
    then
        echo "Error: command '$c' not found" >&2
        exit 3
    fi
done

if test -z "$1"
then
    echo "Please call me with an input file..." >&2
    exit 1
fi

if grep -Eqsv '^[A-Za-z]+$' "$1"
then
    echo "Found invalid line, check the file!" >&2
    exit 2
fi
_if="$1"

if test $(( $( cat "$_if" | wc -l ) % 3 )) -ne 0
then
    echo "Number of lines not multiple of 3" >&2
    exit 2
fi

_fc=$( mktemp ) # becomes first rucksack
_sc=$( mktemp ) # becomes second rucksack
_tc=$( mktemp ) # third rucksack
_si='' # shared items
_gc=0 # group counter
_bl='' # badges list
while IFS= read -r line <&3
do
    _gc=$(( _gc + 1 ))
    case $(( _gc % 3 )) in
        1) # 1st member of group
            printf '%s' "$line" | fold -w 1 | sort -uo "$_fc"
            ;;
        2) # 2nd member of group
            printf '%s' "$line" | fold -w 1 | sort -uo "$_sc"
            _si="$( comm -12 "$_fc" "$_sc" )"
            ;;
        0) # 3rd member of group
            printf '%s' "$line" | fold -w 1 | sort -uo "$_tc"
            _bl="$_bl $( printf '%s' "$_si" | comm -12 "$_tc" - )"
            ;;
        *) echo "?!?$_gc!?!" >&2 ;;
    esac
done 3<"$_if"
rm "$_fc" "$_sc" "$_tc"
#echo "$_bl" | cat -vet

_ps=0 # priority sum
_ac=0 # ASCII code
for character in $( echo "$_bl" )
do
    _ac=$( printf '%d' "'$character" )
    case "$character" in
        [a-z]) # a is 97 but should translate to 1
            _ps=$(( _ps + _ac - 96 )) ;;
        [A-Z]) # A is 65 but should translate to 27
            _ps=$(( _ps + _ac - 38 )) ;;
        *) echo "$character=$_ac=??" >&2 ;;
    esac
done

echo "$_ps"

Le vice avait été poussé jusqu'à éviter grep -o car cette option n'est pas POSIX (bien que je la trouve un peu partout ceci dit.) Ici, je propose une autre approche que j'avais mentionnée dans l'un de mes journaux. En terme de perfs, faut voir.

$ time echo "split" | sed 's/./&\n/g'
s
p
l
i
t


real    0m0.014s
user    0m0.002s
sys     0m0.004s
$ time echo "split" | grep -o '.'
s
p
l
i
t

real    0m0.006s
user    0m0.002s
sys     0m0.004s
$ time echo "split" | fold -w1
s
p
l
i
t

real    0m0.008s
user    0m0.002s
sys     0m0.007s

Il y a certainement des optimisations possibles, mais comme on le sait faut pas s'y lancer prématurément.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Pour la première partie.

#!/bin/sh
# $1: input file

for c in 'grep' 'seq' 'test'
do
    if ! command -v "$c" >/dev/null
    then
        echo "Error: command '$c' not found" >&2
        exit 3
    fi
done

if test -z "$1"
then
    echo "Please call me with an input file..." >&2
    exit 1
fi

if grep -Eqsv '^[0-9]+-[0-9]+,[0-9]+-[0-9]+$' "$1"
then
    echo "Found invalid line, check the file!" >&2
    exit 2
fi
_if="$1"

# First or Second elves in paire
# Start or End of section number
_oc=0 # Overlap Counter
while IFS='-,' read -r _fs _fe _ss _se <&3
do
    _s1=",$( seq -s ',' $_fs $_fe )" # 1st range sections list
    _s2=",$( seq -s ',' $_ss $_se )" # 2nd range sections list
    if test -z "${_s1##*$_s2*}" ||
        test -z "${_s2##*$_s1*}"
    then
        _oc=$(( _ic + 1 ))
    fi
done 3<"$_if"
echo "$_oc"

Je ne sais pas pourquoi ça m'a fait penser à seq et jot (que j'ai déjà eu à mentionner.)

    _s1=",$( jot -s ',' - $_fs $_fe )," # 1st range sections list
    _s2=",$( jot -s ',' - $_ss $_se )," # 2nd range sections list

L'écriture en extension a été inspiré par l'exemple donné

.234.....  2-4
.....678.  6-8

…mais j'utilise un séparateur car on peut avoir des nombre de plusieurs chiffres

,2,3,4, 2-4
,6,7,8, 6-8


Après il suffit de vérifier qu'une des deux sous-chaines est dans l'autre. :)
Ici j'ai utilisé les possibilités de substitution et expansion du shell, mais on peut faire appel à une autre commande pour plus de lisibilité.

    if echo "$_s2" | grep -qs "$_s1"
    then
        _oc=$(( _ic + 1 ))
    elif echo "$_s1" | grep -qs "$_s2"
    then
        _oc=$(( _ic + 1 ))
    fi

Noter que l'on peut utiliser seq et jot sans option -s puis rediriger dans un fichier distinct puis appliquer comm aux deux fichiers comme déjà vu.
Exceptionnellement, je mentionne deux commandes non POSIX mais répandues (cependant la syntaxe du script demeure sans bashism.) On peut remplacer par une fonction maison pour plus de portabilité.
Dans tous les cas, on traite le problème en peu de lignes avec les outils disponibles. :)

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Quelles commande(s) allons-nous (re)découvrir aujourd'hui ?
Voici pour la première partie.

#!/bin/sh
# $1: input file

for c in 'grep' 'sed' 'sort' 'test'
do
    if ! command -v "$c" >/dev/null
    then
        echo "Error: command '$c' not found" >&2
        exit 3
    fi
done

if test -z "$1"
then
    echo "Please call me with an input file..." >&2
    exit 1
fi

if grep -Eqsv '^[a-zA-Z]+$' "$1"
then
    echo "Found invalid line, check the file!" >&2
    exit 2
fi
_if="$1"

_fc=$( mktemp ) # first compartiment
_sc=$( mktemp ) # second compartiment
_si='' # shared items
while IFS= read -r line <&3
do
    printf '%s' "$line" | cut -c -$(( ${#line}/2 )) |
        sed 's/./&\n/g' | sort -uo "$_fc"
    printf '%s' "$line" | cut -c $(( ${#line}/2 + 1 ))- |
        sed 's/./&\n/g' | sort -uo "$_sc"
    _si="$_si $( comm -12 "$_fc" "$_sc" )"
done 3<"$_if"
rm "$_fc" "$_sc"
#echo "$_si" | cat -vet

_ps=0 # priority sum
_ac=0 # ASCII code
for character in $( echo "$_si" )
do
    _ac=$( printf '%d' "'$character" )
    case "$character" in
        [a-z]) # a is 97 but should translate to 1
            _ps=$(( _ps + _ac - 96 )) ;;
        [A-Z]) # A is 65 but should translate to 27
            _ps=$(( _ps + _ac - 38 )) ;;
        *) echo "$character=$_ac=??" >&2 ;;
    esac
done
echo "$_ps"

La grande difficulté est que l'écriture suivante (à laquelle j'ai initialement pensée) n'est pas POSIX (c'est une facilité de (ba|k|z)sh mais pas reconnue dans ash par exemple)

_fc='' # first compartiment
_sc='' # second compartiment
_si='' # shared items
while IFS= read -r line
do
    _fc="$( printf '%s' "$line" | cut -c -$(( ${#line}/2 )) |
        sed 's/./&\n/g' | sort )"
    _sc="$( printf '%s' "$line" | cut -c $(( ${#line}/2 + 1 ))- |
        sed 's/./&\n/g' | sort )"
    _si="$_si $( comm -12 <( printf '%s' "$_fc" ) <( printf '%s' "$_sc" ) )"
done <"$_if"

Pas grave, on troque l'utilisation de RAM (dont la machine où j'ai testé manque un peu) contre des fichiers (j'ai des E/S sur disque assez performantes pour que ce ne soit pas problématique.)

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

Dans le même esprit que pour $VISUAL, il faut utiliser $PAGER si ce n'est pas déjà le cas.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume

À corriger : cyclimse

Sinon, je fais parti des personnes qui étaient ravies de lire l'annonce sur lichess.
Gros boulot en perspective pour la FSC ; mais ce genre d'audit est hélas nécessaire.

“It is seldom that liberty of any kind is lost all at once.” ― David Hume