Como encontrar uma linha com menos caracteres

Estou escrevendo um script de shell, usando qualquer comando geral do UNIX. Eu tenho que recuperar a linha que tem menos caracteres (espaço em branco incluído). Pode haver até 20 linhas.

Eu sei que posso usar head -$L | tail -1 | wc -mpara encontrar a contagem de caracteres da linha L. O problema é que o único método em que posso pensar, usando isso, seria escrever manualmente uma bagunça de instruções if, comparando os valores.

Dados de exemplo:

seven/7
4for
8 eight?
five!

Voltaria, 4forpois essa linha tinha menos caracteres.

No meu caso, se várias linhas tiverem o menor comprimento, uma única deverá ser retornada. Não importa qual é selecionado, desde que tenha o comprimento mínimo. Mas não vejo mal em mostrar os dois lados para outros usuários com outras situações.

Um jeito Perl. Observe que, se houver muitas linhas do mesmo comprimento mais curto, essa abordagem imprimirá apenas uma delas:

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

Explicação

• perl -lne: -nsignifica "ler o arquivo de entrada linha por linha", -lfaz com que as novas linhas finais sejam removidas de cada linha de entrada e uma nova linha seja adicionada a cada printchamada; e -eé o script que será aplicado a cada linha.
• $m//=$_: defina $ma linha atual ( $_), a menos que $mesteja definido. O //=operador está disponível desde o Perl 5.10.0.
• $m=$_ if length()<length($m): se o comprimento do valor atual de $mfor maior que o comprimento da linha atual, salve a linha atual ( $_) como $m.
• END{print $m if $.}: depois que todas as linhas tiverem sido processadas, imprima o valor atual da $mmenor linha. Os if $.garante que isto só acontece quando o número da linha ( $.) é definido, evitando a impressão de uma linha de vazio para a entrada em branco.

Como alternativa, como seu arquivo é pequeno o suficiente para caber na memória, você pode:

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

Explicação

• @K=sort{length($a) <=> length($b)}<>: <>aqui está uma matriz cujos elementos são as linhas do arquivo. Eles sortos classificarão de acordo com seu comprimento e as linhas classificadas serão salvas como matriz @K.
• print "$K[0]": imprime o primeiro elemento da matriz @K: a linha mais curta.

Se você deseja imprimir todas as linhas mais curtas, pode usar

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

Com sqlite3:

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

Aqui está uma variante de uma awksolução para imprimir a primeira linha mínima encontrada:

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

que pode ser simplesmente estendido por uma condição para imprimir todas as linhas mínimas:

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

O Python é bastante conciso e o código faz o que diz na lata:

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

A vírgula final é obscura, admito. Impede que a declaração de impressão adicione uma quebra de linha adicional. Além disso, você pode escrever isso no Python 3 suportando 0 linhas como:

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

Eu sempre adoro soluções com scripts de shell puro (sem 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"

Nota :

Há um problema com NUL bytes na entrada. Então, printf "ab\0\0\ncd\n" | bash this_scriptimprime em abvez de cd.

Aqui está uma zshsolução pura (ela imprime todas as linhas com o comprimento mínimo, de file):

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

Exemplo de entrada:

seven/7
4for
8 eight?
five!
four

A saída é:

4for
four

Eu acho que precisa de uma breve explicação :-)

Primeiro, configuramos o separador de campo interno como nova linha:

IFS=$'\n';

Até aí tudo bem, agora a parte mais difícil. printusa o -lsinalizador para imprimir o resultado separado por novas linhas em vez de espaços.

Agora, começamos por dentro:

$(<file)

O arquivo é lido linha por linha e tratado como matriz. Então:

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

A obandeira diz que o resultado deve ser ordenado em ordem crescente, os @meios para tratar o resultado como um array também. A parte behind ( //?/?) é uma substituição que substitui todos os caracteres por a ?. Agora:

${~...[1]}

Pegamos o primeiro elemento da matriz [1], que é o mais curto, no seu caso, é agora ????.

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

A correspondência é realizada em cada elemento da matriz separadamente e os elementos da matriz não correspondentes são removidos ( M). Cada elemento que corresponde ????(4 caracteres) permanece na matriz. Portanto, os elementos restantes são os que têm 4 caracteres (os mais curtos).

Editar: se você precisar de apenas uma das linhas mais curtas, esta versão modificada imprime a primeira:

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

... e o vencedor é ... a linha 2, ao que parece.

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

Mas o problema é que todas as linhas devem ter mais do que o dobro de comprimento para que funcionem - portanto, LINE_MAX seja efetivamente dividido pela metade. A causa é que ele está usando - o que, uma base 1? - para representar o comprimento da linha. Uma abordagem semelhante - e talvez mais organizada - pode ser compactar essas informações no fluxo. A primeira ideia nesse sentido que me ocorre é que eu deveria 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

Isso imprime ...

2
4for

Outro, apenas 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

A sintaxe é compatível com os padrões - mas isso não garante que nenhum antigo sed lidem com os problemas \(reference-group\)\{counts\}corretamente - muitos não.

Basicamente, aplica o mesmo regexp à entrada repetidamente - o que pode ser muito benéfico quando é hora de compilá-las. Esse padrão é:

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

Que corresponde a diferentes cadeias de maneiras diferentes. Por exemplo:

string1\nstring2\nstring3

... é correspondido com sin \1e ''a cadeia nula em\2 .

1\nstring2\nstring3

... é combinado com 1in \1e \nstring2\nstring3in\2

\nstring2\nstring3

... é correspondido com \nin \1e ''a cadeia nula em \2. Isso seria problemático se houvesse alguma chance de uma linha de \new ocorrer no início do espaço do padrão - mas os comandos /^\n/De //!gsão usados ​​para evitar isso. Usei, [^\n]mas outras necessidades desse pequeno script tornaram a portabilidade uma preocupação e não fiquei satisfeito com as muitas maneiras pelas quais ele é mal interpretado. Além disso, .é mais rápido.

\nstring2
string1

... correspondem \ne snovamente \1e ambos obtêm a ''cadeia nula \2. Linhas vazias não coincidem.

Quando o padrão é aplicado gglobalmente, os dois desvios - o viés padrão mais à esquerda e o lado direito menor\n ew do direito - são contrabalançados para efetuar um salto. Alguns exemplos:

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

... se todos aplicados (não em sucessão) à seguinte sequência ...

string1\nstring2

... irá transformá-lo em ...

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

Basicamente, eu uso o regexp para sempre manipular apenas a primeira linha em qualquer espaço de padrão ao qual eu o aplico. Isso me permite manipular duas versões diferentes de uma linha de correspondência mais curta retida até o momento e a linha mais recente sem recorrer a loops de teste - cada substituição aplicada lida com todo o espaço do padrão de uma só vez.

As versões diferentes são necessárias para comparações literais de string / string - portanto, deve haver uma versão de cada linha em que todos os caracteres sejam garantidos como iguais. Mas é claro que, se um ou outro deveria realmente ser a linha mais curta de entrada mais precoce, a linha impressa na saída provavelmente deveria ser a versão original da linha - e não a que eu higienizei / homogeneizei para fins de comparação. E então eu preciso de duas versões de cada.

É lamentável que outra necessidade seja muita troca de buffer para lidar com o mesmo - mas pelo menos nenhum buffer excede mais do que as quatro linhas necessárias para se manter atualizado - e, portanto, talvez não seja terrível.

De qualquer forma, para cada ciclo, a primeira coisa que acontece é uma transformação na linha lembrada - porque a única cópia realmente salva é o original literal - em ...

^               \nremembered line$

... e depois a nlinha de entrada ext substitui qualquer buffer antigo. Se não contiver pelo menos um único caractere, será efetivamente ignorado. Seria muito mais fácil apenasq a primeira linha em branco, mas, bem, meus dados de teste tinham muitos deles e eu queria lidar com vários parágrafos.

E, se ele contém um caractere, sua versão literal é anexada à linha lembrada e sua versão de comparação espaçada é posicionada na cabeça do espaço do padrão, assim:

^   \n               \nremembered line\nnew$

Por último, uma substituição é aplicada a esse espaço de padrão:

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

Portanto, se a nova linha puder caber no espaço necessário para conter a linha lembrada com pelo menos um caractere de reposição, as duas primeiras linhas serão substituídas, senão somente a primeira.

Independentemente do resultado, a primeira linha no espaço do padrão é sempre Dexcluída no final do ciclo antes de iniciar novamente. Isso significa que, se a nova linha for mais curta que a última, a string ...

new

... é enviado de volta à primeira substituição do ciclo, que sempre tira apenas o primeiro caractere de nova linha - e, portanto, permanece inteiro. Mas se não for, então a string ...

remembered line\nnew

... começará o próximo ciclo e a primeira substituição retirará a string ...

\nnew

...toda vez.

Na última linha, a linha lembrada é impressa para padronizar e, portanto, para os dados de exemplo fornecidos, ela imprime:

4for

Mas, sério, use tr.

Experimentar:

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

A idéia é usar awkpara imprimir primeiro o comprimento de cada linha. Isso aparecerá como:

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

Em seguida, use a contagem de caracteres para classificar as linhas sort, cutpara se livrar da contagem e headmanter a primeira linha (aquela com menos caracteres). Obviamente, você pode usar tailpara obter a linha com mais caracteres neste caso.

(Isso foi adotado a partir desta resposta )

Com o POSIX awk:

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

Tomando emprestado algumas das idéias de @ mikeserv:

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

O primeiro sed faz o seguinte:

• h salva a linha original no buffer de espera
• Substitua todos os caracteres da linha por : - para remover qualquer perigo de injeção de código
• Substitua a linha inteira por expr length "whole line" - esta é uma expressão de shell que pode ser avaliada
• O comando e paras é uma extensão GNU sed para avaliar o espaço do padrão e colocar o resultado de volta no espaço do padrão.
• G anexa uma nova linha e o conteúdo do espaço em espera (a linha original) ao espaço do padrão
• o final ssubstitui a nova linha por uma guia

O número de caracteres agora é um número no início de cada linha, portanto, sort -nclassifica pelo comprimento da linha.

A final sedremove todas as linhas, exceto a primeira (menor) e o comprimento da linha, e imprime o resultado.

Ocorreu-me que tudo é possível em uma sedexpressão. Não é bonito:

$ 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
$ 

Quebrando isso:

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

O BSD sed no OS X é um pouco mais exigente com as novas linhas. Esta versão funciona para as versões BSD e GNU do 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
$

_{Observe que esta é mais uma resposta "porque é possível" do que uma tentativa séria de fornecer uma resposta para as melhores práticas. Eu acho que isso significa que eu tenho jogado muito code-colf}

Outra solução perl: armazene as linhas em um hash de matrizes, a chave de hash sendo o comprimento da linha. Em seguida, imprima as linhas com a tecla mínima.

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

4for

Para obter apenas a primeira linha mais curta:

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

Para obter todos os fiapos mais curtos, mude {p;q}parap

Outro método (um tanto incomum) é sortfazer a classificação real por comprimento . É relativamente lento, mesmo com linhas curtas, e se torna dramaticamente mais lento à medida que o comprimento da linha aumenta.
No entanto, acho que a idéia de classificar por sobreposição de chaves . Estou publicando para o caso de outras pessoas também acharem interessante / informativo.

Como funciona:
classifique por variantes de comprimento da mesma chave - key 1que abrange toda a linha.
Cada variante de chave sucessiva incrementa o comprimento da chave em um caractere, até o comprimento da linha mais longa do arquivo (determinada por wc -L)

Para obter apenas a primeira linha mais curta (classificada):

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

que é o mesmo que:

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

Supondo que linhas em branco não sejam consideradas a linha mais curta e que possam existir linhas em branco, o AWK puro a seguir funcionará:

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

Que tal usar classificação?

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

Com o GNU awk

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

• Leia cada linha em uma matriz indexada pelo comprimento da linha.

• Defina PROCINFO["sorted_in"]como @ind_num_ascpara forçar a verificação da matriz a ser ordenada pelo índice da matriz, classificada numericamente

• A configuração da PROCINFOmaneira acima força a linha com o menor comprimento a ser capturada primeiro na travessia da matriz. Portanto, imprima o primeiro elemento da matriz e saia

Isso tem a desvantagem de demorar um nlognpouco, enquanto algumas das outras abordagens estão ndentro do prazo.

Método de ferramentas shell de nível médio, sem 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