Как напечатать самую длинную строку в файле?

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

cat ./text | awk ' { if ( length > x ) { x = length; y = $0 } }END{ print y }'

UPD : обобщение всех советов в комментариях

awk 'length > max_length { max_length = length; longest_line = $0 } END { print longest_line }' ./text 

cat filename | awk '{ print length }' | sort -n | tail -1

sed -rn "/.{$(<file expand -t1 |wc -L)}/{p;q}" file

Сначала он читает файл внутри подстановки команд и выводит длину самой длинной строки (ранее expandконвертирует табуляцию в пробелы, чтобы преодолеть семантику wc -L- каждая вкладка в строке будет добавлять 8 вместо 1 к длине строки). Затем эта длина используется в sedвыражении, означающем «найти строку с таким количеством символов, напечатать ее и выйти». Так что это на самом деле может быть настолько оптимальным, так как самая длинная строка находится рядом с верхом файла, хе-хе (спасибо большое за потрясающие и конструктивные комментарии).

Другой, я думал раньше, чем sed (в bash):

#!/bin/bash
while read -r line; do
    (( ${#line} > max )) && max=${#line} && longest="$line"
done
echo "$longest"

Вот решение Perl:

perl -e 'while(<>){
           $l=length;  
           $l>$m && do {$c=$_; $m=$l}  
         } print $c' file.txt 

Или, если вы хотите напечатать все самые длинные строки

perl -e 'while(<>){
           $l=length;
           push @{$k{$l}},$_;
           $m=$l if $l>$m;
         } print @{$k{$m}}' file.txt 

Поскольку у меня не было ничего лучше, я запустил несколько тестов для текстового файла 625M. Удивительно, но мое решение на Perl было последовательно быстрее, чем другие. Конечно, разница с принятым awkрешением крошечная, но она есть. Очевидно, что решения, которые печатают несколько строк, работают медленнее, поэтому я отсортировал их по типу, быстрее и медленнее.

Выведите только одну из самых длинных строк:

$ time perl -e 'while(<>){
           $l=length;  
           $l>$m && do {$c=$_; $m=$l}  
         } print $c' file.txt 
real    0m3.837s
user    0m3.724s
sys     0m0.096s



$ time awk 'length > max_length { max_length = length; longest_line = $0 }
 END { print longest_line }' file.txt
real    0m5.835s
user    0m5.604s
sys     0m0.204s



$ time sed -rn "/.{$(<file.txt expand -t1 |wc -L)}/{p;q}" file.txt 
real    2m37.348s
user    2m39.990s
sys     0m1.868s

Вывести все самые длинные строки:

$ time perl -e 'while(<>){
           $l=length;
           push @{$k{$l}},$_;
           $m=$l if $l>$m;
         } print @{$k{$m}}' file.txt 
real    0m9.263s
user    0m8.417s
sys     0m0.760s


$ time awk 'length >x { delete y; x=length }
     length==x { y[NR]=$0 } END{ for (z in y) print y[z] }' file.txt
real    0m10.220s
user    0m9.925s
sys     0m0.252s


## This is Chris Down's bash solution
$ time ./a.sh < file.txt 
Max line length: 254
Lines matched with that length: 2
real    8m36.975s
user    8m17.495s
sys     0m17.153s

Grep первая самая длинная линия

grep -Em1 "^.{$(wc -L <file.txt)}\$" file.txt 

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

Как это работает

Команда состоит из двух частей: grep- и wcвызова:

## grep "^.{$( wc -L F )}$" F

wcИспользуется в расширении процесса, $( ... )так оно выполняется до grep. Он рассчитывает длину самой длинной строки. Синтаксис расширения оболочки смешивается с синтаксисом шаблона регулярного выражения в некоторой путанице, поэтому я разложу расширение процесса:

## wc -L F
42
## grep "^.{42}$" F

Здесь расширение процесса было заменено на возвращаемое значение, создавая используемую grepкомандную строку. Теперь мы можем более легко прочитать регулярное выражение: оно точно соответствует от начала ( ^) до конца ( $) строки. Выражение между ними соответствует любому символу, кроме новой строки, повторяется 42 раза. В совокупности это строки, состоящие ровно из 42 символов.

Теперь вернемся к реальным командам оболочки: grepопция -E( --extended-regexp) позволяет избежать экранирования {}. Option -m 1( --max-count=1) останавливает ее после того, как найдена первая строка. Команда <in wcзаписывает файл в его стандартный ввод, чтобы предотвратить wcпечать имени файла вместе с длиной.

Какие самые длинные строки?

Чтобы сделать примеры более удобочитаемыми, когда имя файла встречается дважды, я буду использовать переменную fдля имени файла; Каждый $fв примере может быть заменен именем файла.

f="file.txt"

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

grep -E -m1 "^.{$(wc -L <"$f")}\$" "$f"

Показать все самые длинные строки - все строки длиной до самой длинной строки:

grep -E "^.{$(wc -L <"$f")}\$" "$f" 

Показать последнюю самую длинную строку - последнюю строку длиной до самой длинной строки:

tac "$f" | grep -E -m1 "^.{$(wc -L <"$f")}\$"

Показать одну самую длинную строку - самая длинная строка длиннее всех других строк или ошибка:

[ $(grep -E "^.{$(wc -L <"$f")}\$" "$f" | wc -l) = 1 ] && grep -E "^.{$(wc -L <"$f")}\$" "$f" 

(Последняя команда даже более неэффективна, чем другие, поскольку она повторяет полную команду grep. Очевидно, что она должна быть разложена таким образом, чтобы выходные данные wcи строки, записанные с помощью grep, сохранялись в переменные.
Обратите внимание, что все самые длинные строки могут фактически быть всеми строками Для сохранения в переменной необходимо сохранить только первые две строки.)

Следующий пример должен был быть и должен был быть комментарием к ответу dmitry.malikov , но из-за бесполезного использования видимого пространства комментариев там я решил представить его здесь, где он, по крайней мере, будет виден. ..

Это простое изменение в ДМИТРИЙ по методу AWK однопроходной.
Он печатает все «равные самые длинные» строки. (Примечание. delete arrayЯвляется расширением Gawk).

awk 'length >x { delete y; x=length }
     length==x { y[NR]=$0 } END{ for (z in y) print y[z] }' file

В чистом виде:

#!/bin/bash

_max_length=0
while IFS= read -r _line; do
    _length="${#_line}"
    if (( _length > _max_length )); then
        _max_length=${_length}
        _max_line=( "${_line}" )
    elif (( _length == _max_length )); then
        _max_line+=( "${_line}" )
    fi
done

printf 'Max line length: %d\n' "${_max_length}"
printf 'Lines matched with that length: %d\n' "${#_max_line[@]}"
(( ${#_max_line[@]} )) && printf '%s\n' '----------------' "${_max_line[@]}"

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

#!/bin/sh

# Author: Surinder

if test $# -lt 2
then
   echo "usage: $0 length file1 file2 ..."
   echo "usage: $0 80 hello.c"
   exit 1
fi

length=$1

shift

LONGLINE=/tmp/longest-line-$$.awk

cat << EOF > $LONGLINE
  BEGIN {
  }

  /.*/ {
    current_length=length(\$0);
    if (current_length >= expected_length) {
       printf("%d at line # %d %s\n", current_length, NR, \$0);
    }
  }

  END {
  }
EOF

for file in $*
do
  echo "$file"
  cat $file | awk -v expected_length=$length -f $LONGLINE |sort -nr
done

rm $LONGLINE

https://github.com/lordofrain/tools/blob/master/longest-line/longest-line.sh

Вы можете использовать wc:

wc -L fileName