จะพิมพ์บรรทัดที่ยาวที่สุดในไฟล์ได้อย่างไร?

ฉันกำลังมองหาวิธีที่ง่ายที่สุดในการพิมพ์บรรทัดที่ยาวที่สุดในไฟล์ ฉันทำ googling แล้วก็แปลกใจที่ไม่สามารถหาคำตอบได้ ฉันมักจะพิมพ์ความยาวของบรรทัดที่ยาวที่สุดในไฟล์ แต่ฉันไม่ทราบวิธีพิมพ์บรรทัดที่ยาวที่สุดจริง ๆ ทุกคนสามารถให้บริการโซลูชั่นในการพิมพ์บรรทัดที่ยาวที่สุดในไฟล์ได้หรือไม่? ขอบคุณล่วงหน้า.

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นิพจน์หมายถึง "ค้นหาบรรทัดจำนวนอักขระที่มีความยาวพิมพ์แล้วออกจาก" ดังนั้นนี่อาจเป็นสิ่งที่ดีที่สุดเนื่องจากเส้นที่ยาวที่สุดอยู่ใกล้กับด้านบนของไฟล์ heheh (ขอบคุณที่ fered สำหรับความคิดเห็นที่ยอดเยี่ยมและสร้างสรรค์)

อีกอย่างหนึ่งที่ฉันคิดไว้ก่อนหน้าหนึ่งคือ:

#!/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 

คำสั่งนั้นอ่านยากผิดปกติโดยไม่มีการฝึกฝนเพราะมันผสมไวยากรณ์ของเชลล์และ regexp
สำหรับคำอธิบายฉันจะใช้รหัสเทียมแบบง่ายก่อน บรรทัดที่ขึ้นต้นด้วย##อย่ารันในเชลล์
รหัสที่ใช้ง่ายนี้ใช้ชื่อไฟล์ F และทำให้การอ้างอิงและส่วนต่าง ๆ ของ regexps อ่านได้ง่าย

มันทำงานอย่างไร

คำสั่งมีสองส่วนคือgrep- และการwcร้องขอ:

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

wcถูกนำมาใช้ในการขยายกระบวนการดังนั้นจึงมีการเรียกใช้ก่อน$( ... ) grepมันจะคำนวณความยาวของเส้นที่ยาวที่สุด ไวยากรณ์การขยายเชลล์ผสมกับไวยากรณ์รูปแบบการแสดงออกปกติในทางที่สับสนดังนั้นฉันจะสลายการขยายกระบวนการ:

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

ที่นี่การขยายกระบวนการถูกแทนที่ด้วยค่าที่จะกลับมาสร้างgrepcommandline ที่ใช้ ตอนนี้เราสามารถอ่านนิพจน์ทั่วไปได้ง่ายขึ้น: มันจับคู่กันตั้งแต่เริ่มต้น ( ^) ถึงท้าย ( $) ของบรรทัด การแสดงออกระหว่างพวกเขาตรงกับตัวละครใด ๆ ยกเว้นการขึ้นบรรทัดใหม่ซ้ำแล้วซ้ำอีก 42 ครั้ง รวมกันนั่นคือบรรทัดที่ประกอบด้วยอักขระ 42 ตัว

ตอนนี้กลับไปที่คำสั่งเชลล์จริง: grepตัวเลือก-E( --extended-regexp) ช่วยให้ไม่สามารถหลบหนี{}เพื่อความสะดวกในการอ่าน ตัวเลือก-m 1( --max-count=1) ทำให้หยุดหลังจากพบบรรทัดแรก <ในwcคำสั่งเขียนไฟล์เพื่อ stdin ของตนเพื่อป้องกัน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แต่เนื่องจากการใช้พื้นที่แสดงความคิดเห็นที่ไร้ประโยชน์ นั้นฉันจึงเลือกที่จะนำเสนอที่นี่ซึ่งอย่างน้อยที่สุดก็จะเห็น ..

นี่เป็นรูปแบบที่เรียบง่ายของวิธีการ single-pass awk ของdmitry
มันพิมพ์บรรทัด "ยาวที่สุด" เท่ากันทั้งหมด (หมายเหตุdelete arrayคือส่วนขยายเพ่งพิศ)

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