Как найти строку с наименьшим количеством символов

Я пишу сценарий оболочки, используя любые общие команды UNIX. Я должен получить строку, которая имеет наименьшее количество символов (включая пробелы). Там может быть до около 20 строк.

Я знаю, что могу использовать, head -$L | tail -1 | wc -mчтобы найти количество символов в строке L. Проблема в том, что единственный способ, который я могу придумать, используя это, состоит в том, чтобы вручную написать беспорядок операторов if, сравнивая значения.

Пример данных:

seven/7
4for
8 eight?
five!

Вернется, 4forтак как эта строка имеет наименьшее количество символов.

В моем случае, если несколько строк имеют самую короткую длину, должна быть возвращена одна. Неважно, какой из них выбран, если он имеет минимальную длину. Но я не вижу вреда в демонстрации обоих способов другим пользователям в других ситуациях.

Perl способ. Обратите внимание, что если имеется много строк одинаковой, самой короткой длины, этот подход выведет только одну из них:

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

объяснение

• perl -lne: -nозначает «читать входной файл построчно», -lприводит к удалению завершающих строк новой строки из каждой строки ввода и новой строки для каждого printвызова; и -eэто сценарий, который будет применяться к каждой строке.
• $m//=$_: установить $mтекущую строку ( $_), если $mне определено. //=Оператор доступен , так как Perl 5.10.0.
• $m=$_ if length()<length($m): если длина текущего значения $mбольше, чем длина текущей строки, сохраните текущую строку ( $_) как $m.
• END{print $m if $.}: после обработки всех строк выведите текущее значение $mсамой короткой строки. Это if $.гарантирует, что это происходит только тогда, когда определен номер строки ( $.), что позволяет избежать печати пустой строки для пустого ввода.

Кроме того, поскольку ваш файл достаточно мал, чтобы поместиться в памяти, вы можете сделать:

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

объяснение

• @K=sort{length($a) <=> length($b)}<>: <>здесь массив, элементы которого являются строками файла. Они sortбудут отсортированы по длине, а отсортированные строки сохранены в виде массива @K.
• print "$K[0]": вывести первый элемент массива @K: самую короткую строку.

Если вы хотите распечатать все самые короткие строки, вы можете использовать

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

С sqlite3:

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

Вот вариант awkрешения для печати первой найденной минимальной строки:

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

который может быть просто расширен на одно условие для печати всех минимальных строк:

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

Python выходит довольно лаконичным, а код делает то, что говорит на олове:

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

Признаюсь, последняя запятая неясна. Это препятствует тому, чтобы оператор печати добавил дополнительный перенос строки. Кроме того, вы можете написать это в Python 3, поддерживая 0 строк, например:

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

Я всегда люблю решения с использованием чистых сценариев оболочки (без 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"

Примечание :

Существует проблема с байтами NUL на входе. Итак, printf "ab\0\0\ncd\n" | bash this_scriptпечатает abвместо cd.

Здесь чистое zshрешение (оно печатает все строки с минимальной длиной, из file):

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

Пример ввода:

seven/7
4for
8 eight?
five!
four

Выход:

4for
four

Я думаю, что нужно краткое объяснение :-)

Сначала мы устанавливаем внутренний разделитель полей на новую строку:

IFS=$'\n';

Пока все хорошо, теперь самая сложная часть. printиспользует -lфлаг для печати результата, разделенного символами новой строки вместо пробелов.

Теперь мы начнем с внутренней стороны:

$(<file)

Файл читается построчно и рассматривается как массив. Затем:

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

oФлаг говорит о том , что результат должен быть заказан в порядке возрастания, на @средства для лечения результата в виде массива тоже. Часть, стоящая за ( //?/?), является заменой и заменяет все символы на ?. В настоящее время:

${~...[1]}

Мы берем первый элемент массива [1], который является самым коротким, в вашем случае его сейчас ????.

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

Сопоставление выполняется для каждого элемента массива отдельно, а несопоставленные элементы массива удаляются ( M). Каждый элемент, который соответствует???? (4 символа) остается в массиве. Таким образом, остальные элементы имеют 4 символа (самые короткие).

Изменить: Если вам нужна только одна из самых коротких строк, эта измененная версия печатает первую:

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

... и победитель ... строка 2, казалось бы.

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

Но проблема в том, что каждая строка должна быть более чем в два раза длиннее, чтобы она работала - поэтому LINE_MAX эффективно уменьшается вдвое. Причина в том, что он использует - что, база 1? - представлять длину линии. Подобный и, возможно, более аккуратный подход может заключаться в сжатии этой информации в потоке. Первая идея, которая приходит мне в голову, заключается в том, что я должен 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

Это печатает ...

2
4for

Еще один, просто 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

Синтаксис соответствует стандартам - но это не гарантирует, что любой старый sedсправится \(reference-group\)\{counts\}правильно - многие этого не делают.

Он в основном применяет одно и то же регулярное выражение для ввода многократно - что может быть очень полезно, когда пришло время их компилировать. Этот шаблон:

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

Который по-разному соответствует различным строкам. Например:

string1\nstring2\nstring3

... совпадает с sin \1и ''нулевой строкой in \2.

1\nstring2\nstring3

... сочетается с 1в \1и \nstring2\nstring3в\2

\nstring2\nstring3

... совпадает с \nin \1и ''нулевой строкой in \2. Это было бы проблематично, если бы была какая-либо вероятность появления \newline в начале пространства шаблонов, но для предотвращения этого используются команды /^\n/D, и //!g. Я использовал, [^\n]но другие потребности в этом небольшом скрипте сделали переносимость проблемой, и я не был удовлетворен многими путями, которые он часто неверно истолковывает. Плюс, .быстрее.

\nstring2
string1

... матч \nи sснова в, \1и оба получают'' нулевую строку \2. Пустые строки не совпадают вообще.

Когда шаблон применяется gлобально, два смещения - как крайнее левое стандартное смещение, так и меньшее правое смещение на боковой \nлинии - уравновешиваются, чтобы вызвать пропуск. Несколько примеров:

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

... если все применяются (не в последовательности) к следующей строке ...

string1\nstring2

... превратит его в ...

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

В основном я использую регулярное выражение, чтобы всегда обрабатывать только первую строку в любом шаблонном пространстве, к которому я его применяю. Это позволяет мне манипулировать двумя различными версиями как сохраненной строки с кратчайшим совпадением, так и самой последней строки, не прибегая к циклам тестирования - каждая примененная замена обрабатывает все пространство шаблона одновременно.

Различные версии необходимы для сравнения строк и строк - поэтому должна быть версия каждой строки, в которой все символы гарантированно равны. Но, конечно, если одна или другая из них на самом деле окажутся самой ранней из самых коротких строк на входе, то строка, напечатанная для вывода, вероятно, должна быть исходной версией строки, а не той, которую я санировал / гомогенизировал для сравнения. И поэтому мне нужны две версии каждого.

К сожалению, еще одной необходимостью является многократное переключение буфера для обработки одного и того же, но, по крайней мере, ни один из буферов никогда не превышает больше, чем четыре строки, необходимые для поддержания актуальности, - и поэтому, возможно, это не страшно.

Во всяком случае, для каждого цикла первое, что происходит, - это преобразование запомненной строки, потому что единственная фактически сохраненная копия - это буквальный оригинал - в ...

^               \nremembered line$

... и после этого nстрока ввода ext перезаписывает любой старый буфер. Если он не содержит хотя бы одного символа, он фактически игнорируется. Было бы намного проще простоq использовать первую появившуюся пустую строку, но в моих тестовых данных их было много, и я хотел обработать несколько абзацев.

И поэтому, если он содержит символ, его буквальная версия добавляется к запомненной строке, а его версия с разнесенным сравнением располагается в начале пространства шаблонов, например так:

^   \n               \nremembered line\nnew$

Последнее замещение применяется к этому образцу пространства:

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

Таким образом, если символ новой строки может уместиться в пределах пространства, необходимого для хранения запомненной строки, по крайней мере, с одним запасным символом, тогда первые две строки заменяются, в противном случае - только первая.

Независимо от результата, первая строка в шаблонном пространстве всегда Dвыбирается в конце цикла, прежде чем начинать снова. Это означает, что если новая строка короче последней строки ...

new

... отправляется обратно к первой замене в цикле, которая всегда будет удаляться только с первого символа новой строки - и поэтому она остается целой. Но если это не так, строка ...

remembered line\nnew

... вместо этого начнется следующий цикл, и первая замена удалит из него строку ...

\nnew

...каждый раз.

В самой последней строке запомненная строка выводится на стандартный вывод, поэтому для приведенных данных примера она печатает:

4for

Но, если серьезно, используйте tr.

Пытаться:

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

Идея состоит в том, awkчтобы сначала напечатать длину каждой строки. Это будет выглядеть как:

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

Затем используйте счетчик символов для сортировки строк sort, cutчтобы избавиться от счетчика и headсохранить первую строку (ту, которая содержит наименьшее количество символов). Вы можете, конечно, использовать, tailчтобы получить строку с наибольшим количеством символов в этом случае.

(Это было принято из этого ответа )

С POSIX awk:

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

Заимствование некоторых идей @ mikeserv:

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

Первый sedделает следующее:

• h сохраняет исходную строку в буфер хранения
• Заменить каждый символ в строке : - чтобы исключить опасность внедрения кода
• Заменить всю строку на expr length "whole line" - это выражение оболочки, которое может быть оценено
• Команда е кs является СЭД расширение GNU для оценки пространства шаблонов и возврата результата в пространство шаблонов.
• G добавляет новую строку и содержимое области удержания (исходной строки) в пространство шаблона
• финал sзаменяет перевод строки на вкладку

Количество символов теперь является числом в начале каждой строки, поэтому sort -nсортируется по длине строки.

Затем финал sedудаляет все, кроме первой (самой короткой) строки и длины строки, и печатает результат.

Мне пришло в голову, что все это возможно в одном sedвыражении. Это не красиво:

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

Разбивая это:

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

BSD sed в OS X немного более привередлив с символами новой строки. Эта версия работает как для BSD, так и для GNU версий 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
$

_{Обратите внимание, что это скорее ответ «потому что это возможно», чем серьезная попытка дать ответ передовой практики. Я думаю, это значит, что я слишком много играю}

Другое решение Perl: хранить строки в хеш-массивах, ключом хеша является длина строки. Затем распечатайте строки с ключом минимума.

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

4for

Чтобы получить только первую короткую строку:

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

Чтобы получить все кратчайшие строки, просто измените {p;q}наp

Другой метод (несколько необычный) состоит в том, чтобы sortвыполнять фактическую сортировку по длине . Это относительно медленно даже с короткими линиями, и становится значительно медленнее, когда длина линии увеличивается.
Тем не менее, я нахожу идею сортировки по перекрывающимся ключам довольно интересной. Я публикую это на тот случай, если другие могут посчитать это интересным / информативным.

Как это работает:
Сортировка по длинам-вариантам одного и того же ключа -key 1 который охватывает всю строку.
Каждый последующий вариант ключа увеличивает длину ключа на один символ до длины самой длинной строки файла (определяется по wc -L)

Чтобы получить только первую (отсортированную) самую короткую строку:

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

что так же, как:

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

Предполагая, что пустые строки не считаются самыми короткими, и что пустые строки могут существовать, будет работать следующий чистый AWK:

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

Как насчет использования сортировки?

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

С GNU awk

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

• Считайте каждую строку в массив, индексированный по длине строки.

• Установите PROCINFO["sorted_in"]для @ind_num_ascпринудительного сканирования массива упорядочения массива по индексу массива, отсортированному по номерам

• Установка PROCINFOописанным выше способом заставляет линию с наименьшей длиной быть выбранной первой при обходе массива. Так что выведите первый элемент из массива и выйдите

Недостатком является nlognто, что некоторые другие подходы nвовремя

Среднеуровневый инструмент оболочки, без sedили 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