Comment trouver la ligne avec le moins de caractères

J'écris un script shell, en utilisant toutes les commandes UNIX générales. Je dois récupérer la ligne qui a le moins de caractères (espace inclus). Il peut y avoir jusqu'à environ 20 lignes.

Je sais que je peux utiliser head -$L | tail -1 | wc -mpour trouver le nombre de caractères de la ligne L. Le problème est que la seule méthode à laquelle je peux penser, en utilisant cela, serait d'écrire manuellement un désordre d'instructions if, en comparant les valeurs.

Exemples de données:

seven/7
4for
8 eight?
five!

Reviendrait 4forcar cette ligne avait le moins de caractères.

Dans mon cas, si plusieurs lignes ont la longueur la plus courte, une seule doit être retournée. Peu importe lequel est sélectionné, tant qu'il est de la longueur minimale. Mais je ne vois pas le mal de montrer les deux façons aux autres utilisateurs dans d'autres situations.

Une façon Perl. Notez que s'il existe plusieurs lignes de la même longueur, la plus courte, cette approche n'en imprimera qu'une:

perl -lne '$m//=$_; $m=$_ if length()<length($m); END{print $m if $.}' file 

Explication

• perl -lne: -nsignifie "lire le fichier d'entrée ligne par ligne", -lentraîne la suppression des nouvelles lignes de fin de chaque ligne d'entrée et l'ajout d'une nouvelle ligne à chaque printappel; et -eest le script qui sera appliqué à chaque ligne.
• $m//=$_: défini $msur la ligne actuelle ( $_) sauf si $mdéfini. L' //=opérateur est disponible depuis Perl 5.10.0.
• $m=$_ if length()<length($m): si la longueur de la valeur actuelle de $mest supérieure à la longueur de la ligne actuelle, enregistrez la ligne actuelle ( $_) sous $m.
• END{print $m if $.}: une fois que toutes les lignes ont été traitées, imprimer la valeur actuelle de $m, la ligne la plus courte. Le if $.garantit que cela ne se produit que lorsque le numéro de ligne ( $.) est défini, évitant d'imprimer une ligne vide pour une entrée vierge.

Alternativement, puisque votre fichier est suffisamment petit pour tenir en mémoire, vous pouvez faire:

perl -e '@K=sort{length($a) <=> length($b)}<>; print "$K[0]"' file 

Explication

• @K=sort{length($a) <=> length($b)}<>: <>voici un tableau dont les éléments sont les lignes du fichier. Le sortles triera en fonction de leur longueur et les lignes triées seront enregistrées en tant que tableau @K.
• print "$K[0]": affiche le premier élément du tableau @K: la ligne la plus courte.

Si vous souhaitez imprimer toutes les lignes les plus courtes, vous pouvez utiliser

perl -e '@K=sort{length($a) <=> length($b)}<>; 
         print grep {length($_)==length($K[0])}@K; ' file 

Avec sqlite3:

sqlite3 <<EOT
CREATE TABLE file(line);
.import "data.txt" file
SELECT line FROM file ORDER BY length(line) LIMIT 1;
EOT

Voici une variante d'une awksolution pour imprimer la première ligne minimale trouvée:

awk '
  NR==1 || length<len {len=length; line=$0}
  END {print line}
'

qui peut simplement être étendu par une condition pour imprimer toutes les lignes minimales:

awk '
  length==len {line=line ORS $0}
  NR==1 || length<len {len=length; line=$0}
  END {print line}'
'

Python est assez concis et le code fait ce qu'il dit sur l'étain:

python -c "import sys; print min(sys.stdin, key=len),"

Je reconnais que la virgule finale est obscure. Il empêche la déclaration d'impression d'ajouter un saut de ligne supplémentaire. De plus, vous pouvez écrire ceci en Python 3 prenant en charge 0 lignes comme:

python3 -c "import sys; print(min(sys.stdin, key=len, default='').strip('\n'))"

J'aime toujours les solutions avec des scripts shell purs (pas d'exec!).

#!/bin/bash
min=
is_empty_input="yes"

while IFS= read -r a; do
    if [ -z "$min" -a "$is_empty_input" = "yes" ] || [ "${#a}" -lt "${#min}" ]; then
        min="$a"
    fi
    is_empty_input="no"
done

if [ -n "$a" ]; then
    if [ "$is_empty_input" = "yes" ]; then
        min="$a"
        is_empty_input="no"
    else
        [ "${#a}" -lt "${#min}" ] && min="$a"
    fi
fi

[ "$is_empty_input" = "no" ] && printf '%s\n' "$min"

Remarque :

Il y a un problème avec les octets NUL en entrée. Donc, printf "ab\0\0\ncd\n" | bash this_scriptimprime abau lieu de cd.

Voici une zshsolution pure (il imprime toutes les lignes avec la longueur minimale, à partir de file):

IFS=$'\n'; print -l ${(M)$(<file):#${~${(o@)$(<file)//?/?}[1]}}

Exemple d'entrée:

seven/7
4for
8 eight?
five!
four

La sortie est:

4for
four

Je pense qu'il a besoin d'une courte explication :-)

Tout d'abord, nous définissons le séparateur de champ interne sur la nouvelle ligne:

IFS=$'\n';

Jusqu'ici tout va bien, maintenant la partie difficile. printutilise le -ldrapeau pour imprimer le résultat séparé par des sauts de ligne au lieu d'espaces.

Maintenant, nous commençons à l'intérieur:

$(<file)

Le fichier est lu ligne par ligne et traité comme un tableau. Ensuite:

${(o@)...//?/?}

Le odrapeau indique que le résultat doit être ordonné dans l'ordre croissant, le @moyen de traiter le résultat comme un tableau aussi. La partie derrière ( //?/?) est une substitution et remplace tous les caractères par un ?. À présent:

${~...[1]}

Nous prenons le premier élément du tableau [1], qui est le plus court, dans votre cas, c'est maintenant ????.

${(M)$(<file):#...}

La correspondance est effectuée séparément sur chaque élément du tableau et les éléments du tableau sans correspondance sont supprimés ( M). Chaque élément qui correspond ????(4 caractères) reste dans le tableau. Les éléments restants sont donc ceux qui ont 4 caractères (les plus courts).

Edit: Si vous n'avez besoin que d'une des lignes les plus courtes, cette version modifiée imprime la première:

IFS=$'\n'; print -l ${${(M)$(<file):#${~${(o@)$(<file)//?/?}[1]}}[1]}

tr -c \\n 1 <testfile |   #first transform every [^\n] char to a 1
grep -nF ''           |   #next get line numbers
paste -d: - testfile  |   #then paste it together with itself
sort  -t: -nk2,2          #then sort on second field

... et le gagnant est ... ligne 2, semble-t-il.

2:1111:4for
4:11111:five!
1:1111111:seven/7
3:11111111:8 eight?

Mais le problème avec cela est que chaque ligne doit plus que doubler pour qu'elle fonctionne - donc LINE_MAX est effectivement réduit de moitié. La raison en est qu'il utilise - quoi, une base 1? - pour représenter la longueur de la ligne. Une approche similaire - et peut-être plus ordonnée - pourrait être de compresser ces informations en flux. La première idée dans ce sens qui me vient à l'esprit est que je devrais le faire unexpand:

tr -c \\n \  <testfile    |   #transform all [^\n] to <space>
unexpand -t10             |   #squeeze every series of 10 to one tab
grep -nF ''               |   #and get the line numbers
sed    's/:/!d;=;:/;h;:big    #sed compares sequential lines
$P;$!N; /\(:[^ ]*\)\( *\)\n.*\1.*\2/!D     #newest line is shorter or...
        g;/:./!q;b big'   |   #not; quit input entirely for blank line
sed -f - -e q testfile        #print only first occurrence of shortest line

Cela imprime ...

2
4for

Un autre, juste sed:

sed -n '/^\n/D;s/\(.\)\(\n.*\)*/\1/g
$p;h;   s// /g;G;x;n;//!g;H;s// /g
G;      s/^\( *\)\(\n \1 *\)\{0,1\}\n//
D'      <infile >outfile

La syntaxe est conforme aux normes - mais ce n'est pas une garantie que n'importe quel ancien sedgérera \(reference-group\)\{counts\}correctement - beaucoup ne le font pas.

Il applique essentiellement le même regexp à l'entrée à plusieurs reprises - ce qui peut être très bénéfique quand il est temps de les compiler. Ce schéma est:

\(.\)\(\n.*\)*

Qui correspond à différentes chaînes de différentes manières. Par exemple:

string1\nstring2\nstring3

... correspond à sin \1et à ''la chaîne nulle in \2.

1\nstring2\nstring3

... est associé à 1in \1and \nstring2\nstring3in\2

\nstring2\nstring3

... correspond à \nin \1et à ''la chaîne nulle in \2. Cela serait problématique s'il y avait une chance qu'un \newline se produise à la tête de l'espace de motif - mais les commandes /^\n/D, et //!gsont utilisées pour empêcher cela. J'ai utilisé, [^\n]mais d'autres besoins pour ce petit script ont rendu la portabilité préoccupante et je n'étais pas satisfait des nombreuses façons dont il est souvent mal interprété. De plus, .c'est plus rapide.

\nstring2
string1

... correspond \net sencore \1et les deux obtiennent la ''chaîne nulle \2. Les lignes vides ne correspondent pas du tout.

Lorsque le motif est appliqué globalement, les deux biais - à la fois le biais standard le plus à gauche et le biais de la ligne droite le moins à droite \n- sont contrebalancés pour effectuer un saut. Quelques exemples:

s/\(.\)\(\n.*\)*/\1:\2/g
s/\(.\)\(\n.*\)*/\2\1:/g
s/\(.\)\(\n.*\)*/\1: /g
s/\(.\)\(\n.*\)*/ :\2/g

... si tous s'appliquent (pas successivement) à la chaîne suivante ...

string1\nstring2

... le transformera en ...

s:t:r:i:n:g:1:\nstring2
s:t:r:i:n:g:\nstring21:
s:t:r:i:n:g:1: 
 : : : : : : :\nstring2

Fondamentalement, j'utilise l'expression rationnelle pour toujours gérer uniquement la première ligne dans n'importe quel espace de modèle auquel je l'applique. Cela me permet de jongler avec deux versions différentes d'une ligne conservée la plus courte jusqu'à présent et de la ligne la plus récente sans avoir recours à des boucles de test - chaque substitution appliquée gère tout l'espace de motif en même temps.

Les différentes versions sont nécessaires pour les comparaisons chaîne / chaîne littérales - il doit donc y avoir une version de chaque ligne où tous les caractères sont garantis égaux. Mais bien sûr, si l'un ou l'autre devait devenir la ligne la plus courte en entrée la plus ancienne, la ligne imprimée en sortie devrait probablement être la version originale de la ligne - pas celle que j'ai désinfectée / homogénéisée pour la comparaison. Et j'ai donc besoin de deux versions de chacune.

Il est malheureux qu'une autre nécessité soit beaucoup de commutation de tampons pour les gérer - mais au moins aucun tampon ne dépasse jamais plus que les quatre lignes nécessaires pour rester à jour - et donc ce n'est peut-être pas terrible.

Quoi qu'il en soit, pour chaque cycle, la première chose qui se produit est une transformation sur la ligne mémorisée - car la seule copie réellement enregistrée est l'original littéral - en ...

^               \nremembered line$

... et ensuite la nligne d'entrée ext écrase tout ancien tampon. S'il ne contient pas au moins un seul caractère, il est effectivement ignoré. Il serait beaucoup plus facile deq la première ligne vierge, mais mes données de test en contenaient beaucoup et je voulais gérer plusieurs paragraphes.

Et donc s'il contient un caractère, sa version littérale est ajoutée à la ligne mémorisée et sa version de comparaison espacée est positionnée en tête de l'espace de motif, comme ceci:

^   \n               \nremembered line\nnew$

Enfin, une substitution est appliquée à cet espace de motif:

s/^\( *\)\(\n \1 *\)\{0,1\}\n//

Donc, si la nouvelle ligne peut tenir dans l'espace nécessaire pour contenir la ligne mémorisée avec au moins un caractère à épargner, les deux premières lignes sont remplacées, sinon seulement la première.

Quel que soit le résultat, la première ligne de l'espace de motif est toujours Dsupprimée à la fin du cycle avant de recommencer. Cela signifie que si la nouvelle ligne est plus courte que la dernière, la chaîne ...

new

... est renvoyé à la première substitution dans le cycle qui sera toujours supprimée uniquement à partir du premier caractère de nouvelle ligne - et il reste donc entier. Mais si ce n'est pas le cas, la chaîne ...

remembered line\nnew

... va commencer le cycle suivant à la place, et la première substitution en supprimera la chaîne ...

\nnew

...à chaque fois.

Sur la toute dernière ligne, la ligne mémorisée est imprimée en sortie standard, et donc pour les données d'exemple fournies, elle imprime:

4for

Mais, sérieusement, utilisez tr.

Essayer:

awk '{ print length, $0 }' testfile | sort -n | cut -d" " -f2- | head -1

L'idée est d'utiliser awkpour imprimer la longueur de chaque ligne en premier. Cela apparaîtra comme:

echo "This is a line of text" | awk '{print length, $0}'
22 This is a line of text

Ensuite, utilisez le nombre de caractères pour trier les lignes sort, cutpour vous débarrasser du nombre et headpour conserver la première ligne (celle avec le moins de caractères). Vous pouvez bien sûr utilisertail pour obtenir la ligne avec le plus de caractères dans ce cas.

(Ceci a été adopté à partir de cette réponse )

Avec POSIX awk:

awk 'FNR==1{l=$0;next};length<length(l){l=$0};END{print l}' file

Emprunter certaines des idées de @ mikeserv:

< testfile sed 'h;s/./:/g;s/.*/expr length "&"/e;G;s/\n/\t/' | \
sort -n | \
sed -n '1s/^[0-9]+*\t//p'

Le premier sedfait ce qui suit:

• h enregistre la ligne d'origine dans le tampon de maintien
• Remplacez chaque caractère de la ligne par : - ceci permet d'éliminer tout danger d'injection de code
• Remplacez toute la ligne par expr length "whole line" - c'est une expression shell qui peut être évaluée
• La commande e pours est une extension GNU sed pour évaluer l'espace modèle et remettre le résultat dans l'espace modèle.
• G ajoute une nouvelle ligne et le contenu de l'espace d'attente (la ligne d'origine) à l'espace de motif
• la finale sremplace la nouvelle ligne par un onglet

Le nombre de caractères est maintenant un nombre au début de chaque ligne, donc sort -ntrie par longueur de ligne.

La finale sedsupprime ensuite toutes les lignes sauf la première (la plus courte) et la longueur de la ligne et imprime le résultat.

Il m'est venu à l'esprit que tout cela est possible en une seule sedexpression. Ce n'est pas joli:

$ sed '1h;s/.*/&\n&/;G;:l;s/\n[^\n]\([^\n]*\)\n[^\n]/\n\1\n/;tl;/\n\n/{s/\n.*//;x};${x;p};d' testfile
4for
$ 

Décomposer cela:

1h            # save line 1 in the hold buffer (shortest line so far)
s/.*/&\n&/    # duplicate the line with a newline in between
G             # append newline+hold buffer to current line
:l            # loop start
s/\n[^\n]\([^\n]*\)\n[^\n]/\n\1\n/
              # attempt to remove 1 char both from current line and shortest line
tl            # jump back to l if the above substitution succeeded
/\n\n/{       # matches if current line is shorter
  s/\n.*//    # remove all but original line
  x           # save new shortest line in hold buffer
}
${            # at last line
  x           # get shortest line from hold buffer
  p           # print it
}
d             # don't print any other lines

Le sed BSD dans OS X est un peu plus capricieux avec les nouvelles lignes. Cette version fonctionne pour les versions BSD et GNU de sed:

$ sed -e '1h;G;s/\([^\n]*\)\(\n\)\(.*\)/\1\2\1\2\3/;:l' -e 's/\(\n\)[^\n]\([^\n]*\n\)[^\n]/\1\2/;tl' -e '/\n\n/{s/\n.*//;x;};${x;p;};d' testfile
4for
$

_{Notez qu'il s'agit plus d'une réponse «parce que c'est possible» que d'une tentative sérieuse de donner une réponse aux meilleures pratiques. Je suppose que cela signifie que je joue trop de code-colf}

Autre solution Perl: stocker les lignes dans un hachage de tableaux, la clé de hachage étant la longueur de la ligne. Ensuite, imprimez les lignes avec la clé minimale.

perl -MList::Util=min -ne '
    push @{$lines{ length() }}, $_;
} END {
    print @{$lines{ min keys %lines }};
' sample 

4for

Pour obtenir uniquement la première ligne la plus courte:

f=file; sed -n "/^$(sed 's/./1/g' $f | sort -ns | sed 's/././g;q')$/{p;q}" $f

Pour obtenir toutes les peluches les plus courtes, passez simplement {p;q}àp

Une autre méthode (quelque peu inhabituelle) consiste à sortfaire le tri réel par longueur . Il est relativement lent, même avec des lignes courtes, et devient considérablement plus lent lorsque la longueur de la ligne augmente.
Cependant, je trouve l'idée du tri par clés superposées très intéressante. Je le poste au cas où d'autres pourraient également le trouver intéressant / informatif.

Fonctionnement:
tri par variantes de longueur de la même clé - key 1qui s'étend sur toute la ligne
Chaque variante de clé successive incrémente la longueur de la clé d'un caractère, jusqu'à la longueur de la plus longue ligne du fichier (déterminée par wc -L)

Pour obtenir uniquement la première ligne la plus courte (triée):

f=file; sort -t'\0' $(seq -f "-k1.%0.0f" $(<"$f" wc -L) -1 1) "$f" | head -n1

ce qui équivaut à:

f=file.in; 
l=$(<"$f" wc -L)
k=$(seq -f "-k1.%0.0f" $l -1 1) 
sort -st'\0' $k "$f" | head -n1

En supposant que les lignes vides ne sont pas considérées comme la ligne la plus courte et que des lignes vides peuvent exister, l'AWK pur suivant fonctionnera:

awk '
    {
        len   = length;
        a[$0] = len
    }
    !len { next }
    !min { min = len }
    len < min { min = len }
    END {
        for (i in a)
            if (min == a[i])
                print i
    }
' infile.txt

Et le tri?

awk '{ print length($0) "\t" $0 }' input.txt | sort -n | head -n 1 | cut -f2-

Avec GNU awk

gawk '
    {
         a[length]=$0
    };
    END
    {
        PROCINFO["sorted_in"]="@ind_num_asc";
        for (i in a)
        {
            print a[i]; 
            exit
        }
    }
    ' file

• Lisez chaque ligne dans un tableau indexé par longueur de ligne.

• Défini PROCINFO["sorted_in"]pour @ind_num_ascforcer le balayage du tableau à être ordonné par l'index du tableau, trié numériquement

• Le réglage de PROCINFOla manière ci-dessus force la ligne ayant la plus petite longueur à être captée en premier dans la traversée du réseau. Donc, imprimez le premier élément du tableau et quittez

Cela a l'inconvénient d'être un nlogncertain temps, certaines des autres approches sont nà temps

Méthode des outils shell de niveau intermédiaire, sans sedou awk:

f=inputfile
head -n $(xargs -d '\n' -L 1 -I % sh -c 'exec echo "%" | wc -c' < $f | 
          cat -n | sort -n -k 2 | head -1 | cut -f 1)  $f | tail -1