Gil Cot ✔ a écrit 6119 commentaires

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

Suis passé à Ranger depuis quelques années pour ma part. Les gestionnaire livrés avec les bureaux graphiques font le boulot aussi.
Après, il y a plusieurs contextes d'utilisation… Sur les postes professionnels, tu ne peux pas forcément installer ce que tu veux (quand tu as la chance d'avoir un poste sous Linux), donc tu peux oublier MC ou Ranger ou autre. Il y aussi les cas où tu peux mais que le binaire n'existe pas et que tu ne peux pas le compiler pour la plateforme (je pense par exemple aux NAS proprios connus.)

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

Merci.

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

Je me dis parfois que c'est u mauvais sort :-) Après, certaines personnes comme Zatalyz ou moi n'ont pas de pot :-/ (je suis témoin aussi que ça se passe très bien pour certaines personnes qui sont parfois aidées par moi …comble de l'ironie ?)

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

Merci pour ton retour complet. Je pense de plus en plus qu'un wiki serait bienvenue, et constate que tu as eu les mêmes déboires que moi avec certaines applis proprios/fermées il y a quelques années. C'est vraiment dommage qu'un truc qui a l'air simple soit emprisonné dans des bases non documentées et incompatibles entre elles.

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

Y en a qui ont plus de chance que d'autres avec l'administration. :-) Je viens de tenter différents horaires et différents jours pour tomber sur une personne qui ne soit pas de mauvaise humeur et en a quelque chose à fiche, et pour l'instant chaque agent des impôts qui m'a reçu a juste tenté de me mener en bateau. Urssaf m'en parle pas, je n'ai pas gardé de bons souvenirs. Comme dit ma tante : je comprends pas que tu continues à défendre le service public alors qu'ils t'en font voir de toutes les couleurs.

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

Tu as déjà de la chance que quelqu'un se déplace (au lieu que ce soit de simples avis de plus en plus menaçants et un guichet qui ne veut rien comprendre) et ai en plus le temps de prendre le café et tailler la discute. Il me semble cependant que ce n'est pas le personnel qui est mis en cause (en tout cas le titre le suggère et je prends le risque de répondre avant de lire l'article) mais plutôt les algorithmes qui les gouvernent et d'un logiciel qui voit essentiellement (voire quasiment que) de la fraude (même à son détriment comme tu le mentionnes dans ton dernier point) et limite veut qu'on tape sur les gens qui ont du mal à survivre (avant dernier point) comme si c'était les gens qui font de l'évasion fiscale (après tout ces personnes n'ont qu'à crever la gueule ouverte pour la beauté des chiffres de la supposée lutte anti-fraude)

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

Tu ne m'as pas lu jusqu'au bout… Je ne parle pas de la capacité à faire data+voix mais du fait que la data active vide plus vite le bousin. Ce n'est pas non plus une question de changer de batterie mais de le recharger. Observe autour de toi si les gens ne rechargent pas au moins une fois par jour (quand ce n'est pas constamment chez certaines personnes) or il m'arrive de faire trois jours sans trouver de prise de courant (et là je préfère qu'on puisse me joindre pour quelque urgence ou, de mon côté, pouvoir appeler les secours.)
C'est bien d'évoquer les opérateurs mais en changer n'annule pas automagiquement une zone blanche. Parfois c'est couvert mais on ne peut pas faire mieux (cas d'un appartement où j'ai vécu et où dans certaines pièces je captais mal, mais mal avec mon opérateur et pas du tout avec les autres donc ton conseil ne fait qu'empirer la situation existante.) De plus, si tu voyages un peu, tu verras que tu n'as pas le choix de l'opérateur partenaire (si t'as droit à l'itinérance et que c'est actif) ni forcément l'envie que ça se fasse (pour info, la voix est chère mais la data fortement plus chère et c'est une raison de plus pour la désactiver si l'on ne veut pas se retrouver avec une facture astronomique.)

Bref, je ne faisais que compléter les conditions requises pour la solution exposée ; ce n'était pas un commentaire contre (alors que j'ai plussé) qu'il faut vouloir combattre à tout prix en occultant le fait qu'il y a pléthore de configurations qui ne sont pas la sienne.

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

Excellente vision…

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

si on trie par global score on est tous à égalité à 0

Normal, il est écrit que « Getting a star first is worth 100 points, second is 99, and so on down to 1 point at 100th place. » (il y a cent points distribués aux cent premières réponses.) J'en déduis que personne dans le groupe n'est au taquet pour répondre vers 5h je crois. (le Time à >24h dans la vue détaillée…)

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

Comme la promesse nocode…
Par contre Lia n'a pas su lancer une recherche web et cliquer sur les résultats (bon j'arrête de la troller mais la question était savoureuse.)

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

Comme ça mime l'or, c'est de la réserve de valeurs pour les primo entrants dans la mine…? Mais bon, ça reste une opinion.

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