Sınırlandırılmış öğelerin tek bir satırını sayısal olarak nasıl sıralayabilirim?

Ben rasgele bir karakter tarafından sınırlanmış bir sayı satırı (veya birçok satır) var. Her satırın öğelerini sınırlayıcıyı koruyarak sayısal olarak sıralamak için hangi UNIX araçlarını kullanabilirim?

Örnekler:

• sayı listesi; girdi 10 50 23 42:; sıralanmış:10 23 42 50
• IP adresi; girdi 10.1.200.42:; sıralanmış:1.10.42.200
• CSV; girdi 1,100,330,42:; sıralanmış:1,42,100,330
• boru ayrılmış; girdi 400|500|404:; sıralanmış:400|404|500

Sınırlayıcı isteğe bağlı olduğundan, seçtiğiniz tek karakterlik bir sınırlayıcı kullanarak bir Yanıt vermekten (veya uzatmaktan) çekinmeyin.

Bunu aşağıdakilerle yapabilirsiniz:

tr '.' '\n' <<<"$aline" | sort -n | paste -sd'.' -

noktaları . sınırlayıcınızla değiştirin .
eklemek -uiçin sortçiftleri kaldırmak için yukarıdaki komuta.

veya gawk( GNU awk ) ile birçok satırı işleyebiliriz, yukarıdakiler de genişletilebilir:

gawk -v SEP='*' '{ i=0; split($0, arr, SEP); 
    while ( ++i<=asort(arr) ){ printf("%s%s", i>1?SEP:"", arr[i]) }; 
        print "" 
}' infile

yerine *alan ayırıcı olarak SEP='*'sizin ile sınırlayıcı .

Notlar: Herhangi bir sayı sınıfını (tamsayı, kayan nokta, bilimsel, Onaltılık, vb.) İşlemek yerine seçeneğini
kullanmanız gerekebilir .-g, --general-numeric-sortsort-n, --numeric-sort

$ aline='2e-18,6.01e-17,1.4,-4,0xB000,0xB001,23,-3.e+11'
$ tr ',' '\n' <<<"$aline" |sort -g | paste -sd',' -
-3.e+11,-4,2e-18,6.01e-17,1.4,23,0xB000,0xB001

Gelen awkgerek değişikliği, hala bu işleme olacaktır.

Kullanmak perlbariz bir sürümü var; verileri bölün, sıralayın, tekrar birleştirin.

Sınırlayıcının iki kez listelenmesi gerekir (bir kez splitve bir kez join)

örneğin ,

perl -lpi -e '$_=join(",",sort {$a <=> $b} split(/,/))'

Yani

echo 1,100,330,42 | perl -lpi -e '$_=join(",",sort {$a <=> $b} split(/,/))'
1,42,100,330

Yana splitregex olduğunu, karakter alıntı gerekebilir:

echo 10.1.200.42 | perl -lpi -e '$_=join(".",sort {$a <=> $b} split(/\./))'
1.10.42.200

-aVe -Fseçeneklerini kullanarak bölmeyi kaldırmak mümkündür. İle -psonuçların önce ve belirtilen döngü, $_otomatik olarak yazdırılır hangi:

perl -F'/\./' -aple '$_=join(".", sort {$a <=> $b} @F)'

Python ve Stephen Harris'in cevabındaki benzer bir fikri kullanmak :

python3 -c 'import sys; c = sys.argv[1]; sys.stdout.writelines(map(lambda x: c.join(sorted(x.strip().split(c), key=int)) + "\n", sys.stdin))' <delmiter>

Yani şöyle bir şey:

$ cat foo
10.129.3.4
1.1.1.1
4.3.2.1
$ python3 -c 'import sys; c = sys.argv[1]; sys.stdout.writelines(map(lambda x: c.join(sorted(x.strip().split(c), key=int)) + "\n", sys.stdin))' . < foo
3.4.10.129
1.1.1.1
1.2.3.4

Ne yazık ki, G / Ç'yi manuel olarak yapmak zorunda kalmak, bunu Perl versiyonundan çok daha az zarif hale getiriyor.

Bash betiği:

#!/usr/bin/env bash

join_by(){ local IFS="$1"; shift; echo "$*"; }

IFS="$1" read -r -a tokens_array <<< "$2"
IFS=$'\n' sorted=($(sort -n <<<"${tokens_array[*]}"))
join_by "$1" "${sorted[@]}"

Misal:

$ ./sort_delimited_string.sh "." "192.168.0.1"
0.1.168.192

Dayalı

• Dizeyi Bash'te bir diziye bölme

• Bash'de bir dizi nasıl sıralanır?

• Bir dizinin öğelerine katılmak ister misiniz?

Kabuk

Daha üst düzey bir dil yüklemek zaman alır.
Birkaç çizgi için kabuğun kendisi bir çözüm olabilir.
Harici komutu sortve komutu kullanabiliriz tr. Biri satırları sıralamada oldukça etkilidir ve diğeri bir sınırlayıcıyı yeni satırlara dönüştürmede etkilidir:

#!/bin/bash
shsort(){
           while IFS='' read -r line; do
               echo "$line" | tr "$1" '\n' |
               sort -n   | paste -sd "$1" -
           done <<<"$2"
    }

shsort ' '    '10 50 23 42'
shsort '.'    '10.1.200.42'
shsort ','    '1,100,330,42'
shsort '|'    '400|500|404'
shsort ','    '3 b,2       x,45    f,*,8jk'
shsort '.'    '10.128.33.6
128.17.71.3
44.32.63.1'

Bu ihtiyaç <<<sadece kullanımı nedeniyle bash . Bu, burada bir doc ile değiştirilirse, çözüm posix için geçerlidir.
Bu sekmeler, boşluk veya kabuk glob karakterlerle alanlarını sıralamak mümkün ( *, ?, [). Her satır sıralandığından yeni satır değil.

Değişim <<<"$2"için <"$2"dosya işlemek ve benzeri aramak:

shsort '.'    infile

Sınırlayıcı tüm dosya için aynıdır. Bu bir sınırlama ise geliştirilebilir.

Ancak sadece 6000 satırlı bir dosyanın işlenmesi 15 saniye sürer. Gerçekten de, kabuk dosyaları işlemek için en iyi araç değildir.

awk

Birkaç satırdan fazla (birkaç 10'dan fazla) için gerçek bir programlama dili kullanmak daha iyidir. Bir awk çözümü şunlar olabilir:

#!/bin/bash
awksort(){
           gawk -v del="$1" '{
               split($0, fields, del)
               l=asort(fields)
               for(i=1;i<=l;i++){
                   printf( "%s%s" , (i==0)?"":del , fields[i] )
               }
               printf "\n"
           }' <"$2"
         }

awksort '.'    infile

Bu, yukarıda belirtilen aynı 6000 satır dosyası için sadece 0.2 saniye sürer.

<"$2"For dosyalarının <<<"$2"kabuk değişkenleri içindeki satırlar için olarak değiştirilebileceğini anlayın .

Perl

En hızlı çözüm perl.

#!/bin/bash
perlsort(){  perl -lp -e '$_=join("'"$1"'",sort {$a <=> $b} split(/['"$1"']/))' <<<"$2";   }

perlsort ' '    '10 50 23 42'
perlsort '.'    '10.1.200.42'
perlsort ','    '1,100,330,42'
perlsort '|'    '400|500|404'
perlsort ','    '3 b,2       x,45    f,*,8jk'
perlsort '.'    '10.128.33.6
128.17.71.3
44.32.63.1'

Bir dosya değişikliğini <<<"$a"basitçe sıralamak ve dosya sürümünü "yerinde" yapmak için perl seçeneklerine "$a"eklemek istiyorsanız -i:

#!/bin/bash
perlsort(){  perl -lpi -e '$_=join("'"$1"'",sort {$a <=> $b} split(/['"$1"']/))' "$2"; }

perlsort '.' infile; exit

sedIP adresinin sekizliklerini sıralamak için kullanma

sedyerleşik bir sortişlevi yoktur, ancak verileriniz aralıkta yeterince kısıtlanmışsa (IP adreslerinde olduğu gibi), manuel olarak basit bir kabarcık sıralaması uygulayan bir sed komut dosyası oluşturabilirsiniz . Temel mekanizma, sıra dışı olan bitişik sayıları aramaktır. Numaralar arızalıysa, değiştirin.

sedSekizli ilk iki çifti için bir (bir arka ayırıcı zorlama üçüncü sekizli son işaretlemek için mevcut olması) ve a: komut kendisi iki arama ve değiştirilebilir dışı sipariş numaraları her bir çifti için komutlar içerir ikincisi üçüncü oktet çifti için (EOL ile biter). Takaslar oluşursa, program komut dosyasının üst kısmına dallanır ve sıra dışı sayılar arar. Aksi takdirde çıkar.

Oluşturulan komut dosyası kısmen:

$ head -n 3 generated.sed
:top
s/255\.254\./254.255./g; s/255\.254$/254.255/
s/255\.253\./253.255./g; s/255\.253$/253.255/

# ... middle of the script omitted ...

$ tail -n 4 generated.sed
s/2\.1\./1.2./g; s/2\.1$/1.2/
s/2\.0\./0.2./g; s/2\.0$/0.2/
s/1\.0\./0.1./g; s/1\.0$/0.1/
ttop

Bu yaklaşım, periyodu, kaçması gereken sınırlayıcı olarak kodlar, aksi takdirde normal ifade sözdizimine (herhangi bir karaktere izin verir) "özel" olacaktır.

Böyle bir sed komut dosyası oluşturmak için bu döngü şunları yapacaktır:

#!/bin/bash

echo ':top'

for (( n = 255; n >= 0; n-- )); do
  for (( m = n - 1; m >= 0; m-- )); do
    printf '%s; %s\n' "s/$n\\.$m\\./$m.$n./g" "s/$n\\.$m\$/$m.$n/"
  done
done

echo 'ttop'

Bu komut dosyasının çıktısını başka bir dosyaya yönlendirin sort-ips.sed.

Bu durumda örnek bir çalışma şöyle görünebilir:

ip=$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256)).$((RANDOM % 256))
printf '%s\n' "$ip" | sed -f sort-ips.sed

Üreten senaryo üzerinde aşağıdaki varyasyon kelimesi sınır işaretlerini kullanır \<ve \>ikinci ikame ihtiyacı kurtulmak için. Bu aynı zamanda, oluşturulan komut dosyasının boyutunu 1,3 MB'dan 900 KB'nin altına indirir ve sedkendisinin çalışma süresini büyük ölçüde azaltır (hangi seduygulamanın kullanıldığına bağlı olarak orijinalin yaklaşık% 50-75'i kadar ):

#!/bin/bash

echo ':top'

for (( n = 255; n >= 0; --n )); do
  for (( m = n - 1; m >= 0; --m )); do
      printf '%s\n' "s/\\<$n\\>\\.\\<$m\\>/$m.$n/g"
  done
done

echo 'ttop'

Burada, sınırlayıcıyı tek başına tahmin eden bir bash:

#!/bin/bash

delimiter="${1//[[:digit:]]/}"
if echo $delimiter | grep -q "^\(.\)\1\+$"
then
  delimiter="${delimiter:0:1}"
  if [[ -z $(echo $1 | grep "^\([0-9]\+"$delimiter"\([0-9]\+\)*\)\+$") ]]
  then
    echo "You seem to have empty fields between the delimiters."
    exit 1
  fi
  if [[ './\' == *$delimiter* ]]
  then
    n=$( echo $1 | sed "s/\\"$delimiter"/\\n/g" | sort -n | tr '\n' ' ' | sed -e "s/\\s/\\"$delimiter"/g")
  else
    n=$( echo $1 | sed "s/"$delimiter"/\\n/g" | sort -n | tr '\n' ' ' | sed -e "s/\\s/"$delimiter"/g")
  fi
  echo ${n%$delimiter}
  exit 0
else
  echo "The string does not consist of digits separated by one unique delimiter."
  exit 1
fi

Çok verimli veya temiz olmayabilir ama işe yarıyor.

Gibi kullanın bash my_script.sh "00/00/18/29838/2".

Aynı sınırlayıcı sürekli olarak kullanılmadığında veya iki veya daha fazla sınırlayıcı birbirini izlediğinde hata döndürür.

Kullanılan sınırlayıcı özel bir karakterse, bu karakter kaçar (aksi takdirde sedbir hata döndürür).

Bu cevap, Q'nun yanlış anlaşılmasına dayanmaktadır, ancak bazı durumlarda yine de doğru olur. Giriş tamamen doğal sayılarsa ve satır başına yalnızca bir sınırlayıcı (Q'daki örnek verilerde olduğu gibi) varsa, doğru çalışır. Ayrıca, her birinin kendi sınırlayıcısına sahip olan ve istenenden biraz daha fazla olan dosyaları içeren dosyaları da ele alacaktır.

Bu kabuk işlevi readstandart girdiden, her satırdaki belirli sınırlayıcıyı (depolanmış ) bulmak için POSIX parametre ikamesini$d kullanır ve bir satırsonu ve o satırın verileriyle trdeğiştirmek $diçin kullanır , ardından her satırın orijinal sınırlayıcılarını geri yükler:\nsort

sdn() { while read x; do
            d="${x#${x%%[^0-9]*}}"   d="${d%%[0-9]*}"
            x=$(echo -n "$x" | tr "$d" '\n' | sort -g | tr '\n' "$d")
            echo ${x%?}
        done ; }

OP'de verilen verilere uygulanır :

printf "%s\n" "10 50 23 42" "10.1.200.42" "1,100,330,42" "400|500|404" | sdn

Çıktı:

10 23 42 50
1.10.42.200
1,42,100,330
400|404|500

Keyfi sınırlayıcılar için:

perl -lne '
  @list = /\D+|\d+/g;
  @sorted = sort {$a <=> $b} grep /\d/, @list;
  for (@list) {$_ = shift@sorted if /\d/};
  print @list'

Gibi bir girişte:

5,4,2,3
6|5,2|4
There are 10 numbers in those 3 lines

O verir:

2,3,4,5
2|4,5|6
There are 3 numbers in those 10 lines

Bu, rakam olmayan (0-9) sınırlayıcıyı işlemelidir. Misal:

x='1!4!3!5!2'; delim=$(echo "$x" | tr -d 0-9 | cut -b1); echo "$x" | tr "$delim" '\n' | sort -g | tr '\n' "$delim" | sed "s/$delim$/\n/"

Çıktı:

1!2!3!4!5

İle perl:

$ # -a to auto-split on whitespace, results in @F array
$ echo 'foo baz v22 aimed' | perl -lane 'print join " ", sort @F'
aimed baz foo v22
$ # {$a <=> $b} for numeric comparison, {$b <=> $a} will give descending order
$ echo '1,100,330,42' | perl -F, -lane 'print join ",", sort {$a <=> $b} @F'
1,42,100,330

İle ruby, hangi biraz benzerperl

$ # -a to auto-split on whitespace, results in $F array
$ # $F is sorted and then joined using the given string
$ echo 'foo baz v22 aimed' | ruby -lane 'print $F.sort * " "'
aimed baz foo v22

$ # (&:to_i) to convert string to integer
$ echo '1,100,330,42' | ruby -F, -lane 'print $F.sort_by(&:to_i) * ","'
1,42,100,330

$ echo '10.1.200.42' | ruby -F'\.' -lane 'print $F.sort_by(&:to_i) * "."'
1.10.42.200

Özel komut ve yalnızca sınırlayıcı dizesini iletme (normal ifade değil). Girişte kayan veriler de varsa çalışır

$ # by default join uses value of $,
$ sort_line(){ ruby -lne '$,=ENV["d"]; print $_.split($,).sort_by(&:to_f).join' ; }

$ s='103,14.5,30,24'
$ echo "$s" | d=',' sort_line
14.5,24,30,103
$ s='10.1.200.42'
$ echo "$s" | d='.' sort_line
1.10.42.200

$ # for file input
$ echo '123--87--23' > ip.txt
$ echo '3--12--435--8' >> ip.txt
$ d='--' sort_line <ip.txt
23--87--123
3--8--12--435

İçin özel komut perl

$ sort_line(){ perl -lne '$d=$ENV{d}; print join $d, sort {$a <=> $b} split /\Q$d/' ; }
$ s='123^[]$87^[]$23'
$ echo "$s" | d='^[]$' sort_line 
23^[]$87^[]$123

Daha fazla okuma - Perl / ruby ​​tek gömlekli bu kullanışlı listeye zaten sahiptim

• perl - sıralama
• yakut - sıralama

Aşağıdakiler, Kabarcık sıralaması yapacak bir komut dosyası oluşturması anlamında Jeff'in cevabındaki bir varyasyondur sed, ancak kendi cevabını garanti etmek için yeterince farklıdır.

Fark, O (n ^ 2) temel normal ifadeleri üretmek yerine, O (n) genişletilmiş düzenli ifadeler üretmesidir. Ortaya çıkan komut dosyası yaklaşık 15 KB büyüklüğünde olacaktır. sedKomut dosyasının çalışma süresi bir saniyenin kesiridir (komut dosyasının oluşturulması biraz daha uzun sürer).

Noktalarla sınırlandırılmış pozitif tam sayıları sıralamakla sınırlıdır, ancak tam sayıların boyutu (sadece 255ana döngüde artış ) veya tam sayıların sayısı ile sınırlı değildir . Sınırlayıcı delim='.', kod değiştirilerek değiştirilebilir .

Düzenli ifadeleri düzeltmek için kafam bitti, bu yüzden başka bir günün detaylarını açıklayacağım.

#!/bin/bash

# This function creates a extended regular expression
# that matches a positive number less than the given parameter.
lt_pattern() {
    local n="$1"  # Our number.
    local -a res  # Our result, an array of regular expressions that we
                  # later join into a string.

    for (( i = 1; i < ${#n}; ++i )); do
        d=$(( ${n: -i:1} - 1 )) # The i:th digit of the number, from right to left, minus one.

        if (( d >= 0 )); then
            res+=( "$( printf '%d[0-%d][0-9]{%d}' "${n:0:-i}" "$d" "$(( i - 1 ))" )" )
        fi
    done

    d=${n:0:1} # The first digit of the number.
    if (( d > 1 )); then
        res+=( "$( printf '[1-%d][0-9]{%d}' "$(( d - 1 ))" "$(( ${#n} - 1 ))" )" )
    fi

    if (( n > 9 )); then
        # The number is 10 or larger.
        res+=( "$( printf '[0-9]{1,%d}' "$(( ${#n} - 1 ))" )" )
    fi

    if (( n == 1 )); then
        # The number is 1. The only thing smaller is zero.
        res+=( 0 )
    fi

    # Join our res array of expressions into a '|'-delimited string.
    ( IFS='|'; printf '%s\n' "${res[*]}" )
}

echo ':top'

delim='.'

for (( n = 255; n > 0; --n )); do
    printf 's/\\<%d\\>\\%s\\<(%s)\\>/\\1%s%d/g\n' \
        "$n" "$delim" "$( lt_pattern "$n" )" "$delim" "$n"
done

echo 'ttop'

Komut dosyası şöyle görünecektir:

$ bash generator.sh >script.sed
$ head -n 5 script.sed
:top
s/\<255\>\.\<(25[0-4][0-9]{0}|2[0-4][0-9]{1}|[1-1][0-9]{2}|[0-9]{1,2})\>/\1.255/g
s/\<254\>\.\<(25[0-3][0-9]{0}|2[0-4][0-9]{1}|[1-1][0-9]{2}|[0-9]{1,2})\>/\1.254/g
s/\<253\>\.\<(25[0-2][0-9]{0}|2[0-4][0-9]{1}|[1-1][0-9]{2}|[0-9]{1,2})\>/\1.253/g
s/\<252\>\.\<(25[0-1][0-9]{0}|2[0-4][0-9]{1}|[1-1][0-9]{2}|[0-9]{1,2})\>/\1.252/g
$ tail -n 5 script.sed
s/\<4\>\.\<([1-3][0-9]{0})\>/\1.4/g
s/\<3\>\.\<([1-2][0-9]{0})\>/\1.3/g
s/\<2\>\.\<([1-1][0-9]{0})\>/\1.2/g
s/\<1\>\.\<(0)\>/\1.1/g
ttop

Oluşturulan normal ifadelerin ardındaki fikir, her tamsayıdan daha küçük sayılar için eşleme oluşturmaktır; bu iki sayı bozuk olur ve bu şekilde değiştirilir. Normal ifadeler birkaç VEYA seçeneğinde gruplanır. Her bir öğeye eklenen aralıklara çok dikkat edin, bazen öyledir {0}, yani hemen önceki öğenin aramadan çıkarılması gerekir. Soldan sağa regex seçenekleri, verilen sayıdan daha küçük olan sayıları şu şekilde eşleştirir:

• olanlar yer
• onlarca yer
• yüzlerce yer
• (büyük sayılar için gerektiğinde devam eder)
• veya daha küçük (basamak sayısı) olarak

Bir örneği hecelemek için, 101(okunabilirlik için ek alanlarla birlikte):

s/ \<101\> \. \<(10[0-0][0-9]{0} | [0-9]{1,2})\> / \1.101 /g

Burada, ilk alternatif 100'den 100'e kadar olan sayılara izin verir; ikinci alternatif, 0 ila 99 arasında bir değere izin verir.

Başka bir örnek 154:

s/ \<154\> \. \<(15[0-3][0-9]{0} | 1[0-4][0-9]{1} | [0-9]{1,2})\> / \1.154 /g

Burada ilk seçenek 150 ila 153; ikincisi 100 ila 149'a izin verir ve sonuncusu 0 ila 99'a izin verir.

Bir döngüde dört kez test etme:

for test_run in {1..4}; do
    nums=$(( RANDOM%256 )).$(( RANDOM%256 )).$(( RANDOM%256 )).$(( RANDOM%256 ))
    printf 'nums=%s\n' "$nums"
    sed -E -f script.sed <<<"$nums"
done

Çıktı:

nums=90.19.146.232
19.90.146.232
nums=8.226.70.154
8.70.154.226
nums=1.64.96.143
1.64.96.143
nums=67.6.203.56
6.56.67.203

Girişi birden çok satıra bölme

Tuşunu kullanarak trgirişi rasgele bir sınırlayıcı kullanarak birden çok satıra bölebilirsiniz.

Bu giriş daha sonra çalıştırılabilir sort( -ngiriş sayısal ise kullanılarak).

Sınırlayıcıyı çıktıda tutmak istiyorsanız, sınırlayıcıyı trgeri eklemek için tekrar kullanabilirsiniz .

örneğin, alanı sınırlayıcı olarak kullanma

cat input.txt | tr " " "\n" | sort -n | tr "\n" " "

girdi: 1 2 4 1 4 32 18 3 çıktı:1 1 2 3 4 4 18 32