Cara menemukan baris dengan karakter paling sedikit

Saya menulis skrip shell, menggunakan perintah UNIX umum. Saya harus mengambil baris yang memiliki karakter paling sedikit (termasuk spasi). Mungkin ada hingga sekitar 20 baris.

Saya tahu saya dapat menggunakan head -$L | tail -1 | wc -muntuk menemukan jumlah karakter dari garis L. Masalahnya adalah, satu-satunya metode yang dapat saya pikirkan, menggunakan itu, akan secara manual menulis kekacauan jika pernyataan, membandingkan nilai-nilai.

Contoh data:

seven/7
4for
8 eight?
five!

Akan kembali 4forkarena garis itu memiliki karakter paling sedikit.

Dalam kasus saya, jika beberapa baris memiliki panjang terpendek, satu baris harus dikembalikan. Tidak masalah yang mana yang dipilih, asalkan panjangnya minimum. Tapi saya tidak melihat ada salahnya menampilkan kedua cara untuk pengguna lain dengan situasi lain.

Cara Perl. Perhatikan bahwa jika ada banyak garis yang sama, panjang terpendek, pendekatan ini hanya akan mencetak salah satunya:

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

Penjelasan

• perl -lne: -nberarti "membaca file input baris demi baris", -lmenyebabkan baris baru terhapus dari setiap baris input dan baris baru ditambahkan ke setiap printpanggilan; dan -eskrip yang akan diterapkan untuk setiap baris.
• $m//=$_: disetel $mke baris saat ini ( $_) kecuali $mditentukan. The //=operator adalah tersedia sejak Perl 5.10.0.
• $m=$_ if length()<length($m): jika panjang nilai saat $mini lebih besar dari panjang garis saat ini, simpan garis saat ini ( $_) sebagai $m.
• END{print $m if $.}: setelah semua baris diproses, cetak nilai saat ini dari $m, garis terpendek. Yang if $.memastikan bahwa ini hanya terjadi ketika nomor baris ( $.) ditentukan, menghindari mencetak baris kosong untuk input kosong.

Atau, karena file Anda cukup kecil untuk muat dalam memori, Anda dapat melakukan:

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

Penjelasan

• @K=sort{length($a) <=> length($b)}<>: di <>sini adalah array yang elemen-elemennya adalah baris-baris file. The sortakan mengurutkan mereka sesuai dengan panjang mereka dan garis diurutkan disimpan sebagai array yang @K.
• print "$K[0]": cetak elemen pertama array @K: baris terpendek.

Jika Anda ingin mencetak semua garis terpendek, Anda dapat menggunakan

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

Dengan sqlite3:

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

Berikut varian awksolusi untuk mencetak garis minimum pertama yang ditemukan:

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

yang dapat diperpanjang dengan satu syarat untuk mencetak semua baris minimum:

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

Python keluar cukup ringkas, dan kode Melakukan Apa Yang Dikatakan Pada Timah:

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

Saya akui bahwa koma terakhir tidak jelas. Ini mencegah pernyataan cetak menambahkan linebreak tambahan. Selain itu, Anda dapat menulis ini dalam Python 3 yang mendukung 0 baris seperti:

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

Saya selalu menyukai solusi dengan skrip shell murni (no 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"

Catatan :

Ada masalah dengan NUL byte di input. Jadi, printf "ab\0\0\ncd\n" | bash this_scriptcetak abbukan cd.

Di sini zshsolusi murni (mencetak semua garis dengan panjang minimal, dari file):

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

Input contoh:

seven/7
4for
8 eight?
five!
four

Output adalah:

4for
four

Saya pikir perlu penjelasan singkat :-)

Pertama, kami mengatur pemisah bidang internal ke baris baru:

IFS=$'\n';

Sejauh ini bagus, sekarang bagian yang sulit. printmenggunakan -lbendera untuk mencetak hasil yang dipisahkan oleh baris baru, bukan spasi.

Sekarang, kita mulai dari dalam:

$(<file)

File dibaca baris demi baris dan diperlakukan sebagai array. Kemudian:

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

The oflag mengatakan bahwa hasilnya harus dipesan dalam urutan menaik, yang @berarti untuk mengobati hasil sebagai array yang terlalu. Bagian di belakang ( //?/?) adalah pengganti yang menggantikan semua karakter dengan a ?. Sekarang:

${~...[1]}

Kami mengambil elemen array pertama [1], yang merupakan yang terpendek, dalam kasus Anda sekarang ????.

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

Pencocokan dilakukan pada setiap elemen array secara terpisah, dan elemen array yang tidak cocok akan dihapus ( M). Setiap elemen yang cocok ????(4 karakter) tetap dalam array. Jadi elemen yang tersisa adalah yang memiliki 4 karakter (yang terpendek).

Sunting: Jika Anda hanya perlu satu baris terpendek, versi modifikasi ini mencetak yang pertama:

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

... dan pemenangnya adalah ... baris 2, sepertinya.

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

Tetapi masalah dengan itu adalah bahwa setiap baris harus lebih dari dua kali panjang agar bisa berfungsi - jadi LINE_MAX dibelah dua secara efektif. Penyebabnya adalah bahwa ia menggunakan - apa, basis 1? - untuk merepresentasikan panjang garis. Pendekatan serupa - dan mungkin lebih rapi - mungkin untuk mengompres informasi tersebut dalam aliran. Gagasan pertama yang muncul dalam benak saya adalah bahwa saya harus melakukannya 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

Cetakan itu ...

2
4for

Satu lagi, hanya 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

Sintaksnya sesuai standar - tapi itu bukan jaminan bahwa yang lama sedakan menangani dengan \(reference-group\)\{counts\}benar - banyak yang tidak.

Ini pada dasarnya menerapkan regexp yang sama untuk memasukkan berulang kali - yang bisa sangat bermanfaat ketika saatnya untuk mengkompilasi mereka. Pola itu adalah:

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

Yang cocok dengan string berbeda dengan cara yang berbeda. Sebagai contoh:

string1\nstring2\nstring3

... cocok dengan sdi \1dan ''string nol di \2.

1\nstring2\nstring3

... cocok dengan 1di \1dan \nstring2\nstring3di\2

\nstring2\nstring3

... cocok dengan \ndi \1dan ''string nol di \2. Ini akan bermasalah jika ada peluang \newline terjadi di kepala ruang pola - tetapi /^\n/D, dan //!gperintah digunakan untuk mencegah hal ini. Saya memang menggunakan [^\n]tetapi kebutuhan lain untuk skrip kecil ini membuat portabilitas menjadi perhatian dan saya tidak puas dengan banyak cara yang sering disalahartikan. Plus, .lebih cepat.

\nstring2
string1

... cocokkan \ndan slagi \1dan keduanya mendapatkan ''string nol \2. Baris kosong tidak cocok sama sekali.

Ketika pola diterapkan secara global , dua bias - baik bias kiri paling standar maupun bias sisi kanan lebih rendah \n- berlawanan arah untuk menghasilkan lompatan. Beberapa contoh:

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

... jika semua diterapkan (tidak berturut-turut) ke string berikut ...

string1\nstring2

... akan mengubahnya menjadi ...

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

Pada dasarnya saya menggunakan regexp untuk selalu hanya menangani baris pertama di setiap pola-ruang yang saya terapkan. Itu memungkinkan saya untuk menyulap dua versi yang berbeda dari kedua jalur yang terpendek-cocok-sejauh-tetap dan yang terbaru tanpa menggunakan loop tes - setiap penggantian yang diterapkan menangani seluruh ruang pola sekaligus.

Versi yang berbeda diperlukan untuk perbandingan string / string literal - jadi harus ada versi setiap baris di mana semua karakter dijamin sama. Tetapi tentu saja jika salah satu dari yang lain benar-benar berakhir menjadi jalur input terpendek yang muncul, maka jalur yang dicetak ke output mungkin harus merupakan versi asli dari jalur tersebut - bukan versi yang telah saya sanitasi / dihomogenisasi untuk kepentingan perbandingan. Jadi saya butuh dua versi masing-masing.

Sangat disayangkan bahwa kebutuhan lain adalah banyak switching buffer untuk menangani yang sama - tetapi setidaknya tidak ada buffer yang melebihi lebih dari empat baris yang diperlukan untuk tetap terkini - dan jadi mungkin itu tidak mengerikan.

Bagaimanapun, untuk setiap siklus, hal pertama yang terjadi adalah transformasi pada baris yang diingat - karena satu-satunya salinan yang benar-benar disimpan adalah yang asli - ke ...

^               \nremembered line$

... dan sesudahnya jalur ninput ext menimpa buffer lama. Jika tidak mengandung setidaknya satu karakter, maka secara efektif diabaikan. Jauh lebih mudahq menggunakan baris kosong pertama, tetapi, well, data pengujian saya memiliki banyak hal dan saya ingin menangani beberapa paragraf.

Dan jika itu memang mengandung karakter, versi literalnya ditambahkan ke baris yang diingat dan versi perbandingannya ditempatkan di kepala ruang pola, seperti ini:

^   \n               \nremembered line\nnew$

Terakhir substitusi diterapkan ke ruang pola itu:

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

Jadi, jika baris baru dapat masuk dalam ruang yang diperlukan untuk memuat baris yang diingat dengan setidaknya satu karakter cadangan, maka dua baris pertama diganti, yang lain hanya yang pertama.

Terlepas dari hasilnya, baris pertama dalam ruang pola selalu Ddihilangkan pada akhir siklus sebelum memulai lagi. Ini berarti bahwa jika baris baru lebih pendek dari yang terakhir ...

new

... dikirim kembali ke subtitusi pertama dalam siklus yang akan selalu dihapus hanya dari karakter baris baru pertama - dan tetap utuh. Tetapi jika tidak maka string ...

remembered line\nnew

... akan memulai siklus berikutnya sebagai gantinya, dan substitusi pertama akan menghapus darinya string ...

\nnew

...setiap saat.

Pada baris terakhir baris yang diingat dicetak ke standar keluar, dan jadi untuk contoh data yang diberikan, ia mencetak:

4for

Tapi, serius, gunakan tr.

Mencoba:

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

Idenya adalah menggunakan awkuntuk mencetak panjang setiap baris terlebih dahulu. Ini akan muncul sebagai:

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

Kemudian, gunakan jumlah karakter untuk mengurutkan garis sort, cutuntuk menghilangkan jumlah dan headuntuk menjaga baris pertama (yang memiliki karakter paling sedikit). Anda tentu saja dapat menggunakan tailuntuk mendapatkan garis dengan karakter terbanyak dalam kasus ini.

(Ini diadopsi dari jawaban ini )

Dengan POSIX awk:

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

Meminjam beberapa gagasan @ mikeserv:

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

Yang pertama sedmelakukan yang berikut:

• h menyimpan baris asli ke buffer penahan
• Ganti setiap karakter dalam baris dengan :- ini untuk menghilangkan bahaya injeksi kode
• Ganti seluruh baris dengan expr length "whole line"- ini adalah ekspresi shell yang dapat dievaluasi
• Perintah e tos adalah ekstensi sed GNU untuk mengevaluasi ruang pola dan mengembalikan hasilnya ke dalam ruang pola.
• G menambahkan baris baru dan isi ruang pegang (garis asli) ke ruang pola
• final smenggantikan baris baru dengan tab

Jumlah karakter sekarang menjadi angka di awal setiap baris, jadi sort -nurutkan berdasarkan panjang garis.

Final sedkemudian menghapus semua kecuali baris pertama (terpendek) dan panjang garis dan mencetak hasilnya.

Terpikir olehku bahwa semuanya mungkin dalam satu sedekspresi. Itu tidak cantik:

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

Hancurkan ini:

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 di OS X sedikit lebih rewel dengan baris baru. Versi ini berfungsi untuk versi sed BSD dan 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
$

_{Perhatikan bahwa ini lebih merupakan jawaban "karena mungkin" daripada upaya serius untuk memberikan jawaban praktik terbaik. Saya kira itu berarti saya telah bermain terlalu banyak kode-colf}

Solusi perl lain: menyimpan garis-garis dalam hash-of-array, kunci hash menjadi panjang garis. Kemudian, cetak garis dengan kunci minimum.

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

4for

Untuk mendapatkan garis terpendek pertama:

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

Untuk mendapatkan semua serat terpendek, ubah saja {p;q}kep

Metode lain (agak tidak biasa) adalah sortmelakukan sort sebenarnya berdasarkan panjangnya . Itu relatif lambat bahkan dengan garis pendek, dan menjadi lebih lambat secara dramatis ketika panjang garis meningkat.
Namun, saya menemukan ide menyortir dengan tombol yang tumpang tindih cukup menarik. Saya mempostingnya kalau-kalau orang lain juga menganggapnya menarik / informatif.

Cara kerjanya:
Urutkan berdasarkan varian panjang dari kunci yang sama - key 1yang membentang seluruh baris.
Setiap varian kunci berturut-turut menambah panjang kunci dengan satu karakter, hingga panjang baris terpanjang file (ditentukan oleh wc -L)

Untuk mendapatkan baris terpendek pertama (diurutkan):

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

yang sama dengan:

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

Dengan asumsi garis kosong tidak dianggap sebagai garis terpendek dan garis kosong itu mungkin ada, AWK murni berikut ini akan berfungsi:

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

Bagaimana dengan menggunakan sortir?

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

Dengan GNU awk

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

• Baca setiap baris menjadi array yang diindeks oleh panjang garis.

• Setel PROCINFO["sorted_in"]untuk @ind_num_ascmemaksa pemindaian array agar dipesan oleh indeks array, diurutkan secara numerik

• Pengaturan PROCINFOdengan cara di atas memaksa garis dengan panjang terkecil untuk diambil pertama kali dalam lintasan array. Jadi cetak elemen pertama dari array dan keluar

Ini memiliki kelemahan karena nlognbeberapa saat dari beberapa pendekatan lain ntepat waktu

Metode alat shell tingkat menengah, tanpa sedatau 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