วิธีค้นหาบรรทัดที่มีอักขระน้อยที่สุด

ฉันกำลังเขียนเชลล์สคริปต์โดยใช้คำสั่ง UNIX ทั่วไป ฉันต้องดึงสายที่มีตัวอักษรน้อยที่สุด (รวมช่องว่าง) สามารถมีได้สูงสุดประมาณ 20 บรรทัด

ฉันรู้ว่าฉันสามารถใช้head -$L | tail -1 | wc -mเพื่อค้นหาจำนวนตัวอักษรของบรรทัด L ปัญหาคือวิธีเดียวที่ฉันสามารถคิดได้โดยใช้สิ่งนั้นคือการเขียนคำสั่งที่ยุ่งเหยิงหากเปรียบเทียบกับค่าต่างๆ

ข้อมูลตัวอย่าง:

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),"

เครื่องหมายจุลภาคสุดท้ายคือปิดบังฉันยอมรับ ช่วยป้องกันคำสั่งการพิมพ์เพิ่ม linebreak เพิ่มเติม นอกจากนี้คุณสามารถเขียนสิ่งนี้ใน 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พิมพ์แทนabcd

นี่คือ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\}อย่างถูกต้อง - หลายคนไม่ได้

โดยทั่วไปแล้วจะใช้ regexp เดียวกันกับการป้อนข้อมูลซ้ำ ๆ - ซึ่งจะเป็นประโยชน์มากเมื่อถึงเวลาที่จะรวบรวมพวกเขา รูปแบบนั้นคือ:

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

ซึ่งจับคู่สตริงที่แตกต่างกันในวิธีต่างๆ ตัวอย่างเช่น:

string1\nstring2\nstring3

... จะถูกจับคู่กับsใน\1และสตริงใน''\2

1\nstring2\nstring3

... ถูกจับคู่กับ1ใน\1และ\nstring2\nstring3ใน\2

\nstring2\nstring3

... จะถูกจับคู่กับ\nใน\1และสตริงใน'' \2นี่จะเป็นปัญหาหากมีโอกาสที่\newline เกิดขึ้นที่ส่วนหัวของพื้นที่รูปแบบ - แต่ใช้คำสั่ง/^\n/Dและและ//!gเพื่อป้องกันสิ่งนี้ ฉันใช้ไปแล้ว[^\n]แต่ความต้องการอื่น ๆ สำหรับสคริปต์ตัวเล็กนี้ทำให้การพกพาเป็นเรื่องที่น่ากังวลและฉันก็ไม่พอใจกับหลาย ๆ วิธีที่มักถูกตีความผิด บวก.เร็วกว่า

\nstring2
string1

... จับคู่\nและsอีกครั้ง\1ทั้งคู่รับ''ค่าสตริง\2ว่าง บรรทัดว่างไม่ตรงกันเลย

เมื่อรูปแบบจะถูกนำไปใช้globallyสองอคติ - ทั้งอคติซ้ายสุดมาตรฐานและเลสเบี้ยนด้านขวา\newline อคติ - มีการทวนความสมดุลจะทำให้เกิดการข้าม ตัวอย่างบางส่วน:

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

โดยทั่วไปฉันใช้ regexp เพื่อจัดการเฉพาะบรรทัดแรกในพื้นที่รูปแบบใด ๆ ที่ฉันใช้มัน ที่ช่วยให้ฉันสามารถเล่นสองรุ่นที่แตกต่างกันของทั้งคู่ที่สั้นที่สุดจับคู่ไกลและสายล่าสุดโดยไม่ต้องหันไปทดสอบลูป - การทดแทนทุกครั้งที่ใช้จะจัดการกับพื้นที่รูปแบบทั้งหมดในครั้งเดียว

รุ่นที่แตกต่างกันมีความจำเป็นสำหรับการเปรียบเทียบสตริง / สตริงตามตัวอักษร - ดังนั้นจะต้องมีเวอร์ชันของแต่ละบรรทัดที่อักขระทั้งหมดรับประกันว่าจะเท่ากัน แต่แน่นอนถ้าหนึ่งหรืออื่น ๆ ควรจบลงจริง ๆ แล้วเป็นบรรทัดที่สั้นที่สุดที่เกิดขึ้นเร็วที่สุดในบรรทัดแล้วพิมพ์บรรทัดที่ส่งออกไปอาจจะเป็นรุ่นดั้งเดิมของบรรทัด - ไม่ใช่คนที่ฉันได้ sanitized / homogenized เพื่อประโยชน์ของการเปรียบเทียบ ดังนั้นฉันต้องการสองรุ่นแต่ละรุ่น

มันเป็นเรื่องโชคร้ายที่ความจำเป็นอีกอย่างหนึ่งคือการสลับบัฟเฟอร์เพื่อจัดการเหมือนกัน - แต่อย่างน้อยบัฟเฟอร์ไม่เกินเกินกว่าสี่บรรทัดที่จำเป็นในการรักษากระแส - และบางทีมันอาจจะไม่น่ากลัว

อย่างไรก็ตามสำหรับแต่ละรอบสิ่งแรกที่เกิดขึ้นคือการเปลี่ยนแปลงในบรรทัดที่จดจำ - เนื่องจากสำเนาที่บันทึกจริงเท่านั้นคือต้นฉบับดั้งเดิม - เป็น ...

^               \nremembered line$

... และหลังจากนั้นnบรรทัดอินพุตอินพุตจะเขียนทับบัฟเฟอร์เก่าใด ๆ หากไม่มีอย่างน้อยหนึ่งตัวอักษรก็จะถูกละเว้นอย่างมีประสิทธิภาพ มันจะง่ายกว่าที่จะ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" - นี่คือนิพจน์เชลล์ซึ่งอาจถูกประเมิน
• คำสั่ง esเป็นส่วนขยาย sed ของ 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 -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: จัดเก็บบรรทัดใน hash-of-arrays คีย์ hash เป็นความยาวบรรทัด จากนั้นพิมพ์บรรทัดด้วยคีย์ต่ำสุด

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