Mengurutkan daftar nama domain (FQDN) mulai dari tld dan bekerja dengan kiri

Saya mencari untuk mengurutkan daftar nama domain (daftar putih filter web) mulai dari TLD dan bekerja ke atas. Saya mencari * nix atau alat windows yang dapat melakukan ini dengan mudah, meskipun skrip juga akan baik-baik saja.

Jadi jika daftar yang Anda berikan

www.activityvillage.co.uk 
ajax.googleapis.com 
akhet.co.uk 
alchemy.l8r.pl 
au.af.mil 
bbc.co.uk 
bensguide.gpo.gov 
chrome.angrybirds.com 
cms.hss.gov 
crl.godaddy.com 
digitalhistory.uh.edu 
digital.library.okstate.edu 
digital.olivesoftware.com

Inilah yang saya inginkan sebagai output.

chrome.angrybirds.com 
crl.godaddy.com 
ajax.googleapis.com 
digital.olivesoftware.com 
digital.library.okstate.edu 
digitalhistory.uh.edu 
bensguide.gpo.gov 
cms.hss.gov 
au.af.mil 
alchemy.l8r.pl 
www.activityvillage.co.uk 
akhet.co.uk 
bbc.co.uk

Kalau-kalau Anda bertanya-tanya mengapa, Squidguard, memiliki cacat bug / desain. Jika keduanya www.example.comdan example.comkeduanya termasuk dalam daftar, maka example.comentri tersebut diabaikan dan Anda hanya dapat mengunjungi konten dari www.example.com. Saya memiliki beberapa daftar besar yang perlu dibersihkan karena seseorang menambahkan entri tanpa melihat terlebih dahulu.

Skrip python sederhana ini akan melakukan apa yang Anda inginkan. Dalam contoh ini saya memberi nama file domain-sort.py:

#!/usr/bin/env python
from fileinput import input
for y in sorted([x.strip().split('.')[::-1] for x in input()]): print '.'.join(y[::-1])

Untuk menjalankannya gunakan:

cat file.txt | ./domain-sort.py

Perhatikan bahwa ini terlihat sedikit lebih buruk karena saya menulis ini lebih atau kurang satu-liner sederhana saya harus menggunakan notasi irisan di[::-1] mana nilai-nilai negatif bekerja untuk membuat salinan dari daftar yang sama dalam urutan terbalik daripada menggunakan lebih deklaratif reverse()yang melakukannya di tempat dengan cara yang merusak kompabilitas.

Dan ini versi yang sedikit lebih panjang, tapi mungkin lebih mudah dibaca yang menggunakan reversed()yang mengembalikan iterator, maka perlu juga membungkusnya list()untuk mengkonsumsi iterator dan menghasilkan daftar:

#!/usr/bin/env python
from fileinput import input
for y in sorted([list(reversed(x.strip().split('.'))) for x in input()]): print '.'.join(list(reversed(y)))

Pada file dengan 1.500 garis yang diurutkan secara acak, dibutuhkan ~ 0,02 detik:

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.02
Maximum resident set size (kbytes): 21632

Pada file dengan 150.000 garis yang disortir secara acak, dibutuhkan sedikit lebih dari 3 detik:

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:03.20
Maximum resident set size (kbytes): 180128

Ini adalah versi yang bisa dibilang lebih mudah dibaca yang melakukan reverse()dan sort()di tempat, tetapi berjalan dalam jumlah waktu yang sama, dan sebenarnya membutuhkan sedikit lebih banyak memori.

#!/usr/bin/env python
from fileinput import input

data = []
for x in input():
   d = x.strip().split('.')
   d.reverse()
   data.append(d)
data.sort()
for y in data:
   y.reverse()
   print '.'.join(y)

Pada file dengan 1.500 garis yang diurutkan secara acak, dibutuhkan ~ 0,02 detik:

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.02
Maximum resident set size (kbytes): 22096

Pada file dengan 150.000 garis yang disortir secara acak, dibutuhkan sedikit lebih dari 3 detik:

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:03.08
Maximum resident set size (kbytes): 219152

Berikut ini skrip PowerShell yang harus melakukan apa yang Anda inginkan. Pada dasarnya itu melemparkan semua TLD ke dalam array membalikkan setiap TLD, mengurutkannya, membalikkannya kembali ke urutan aslinya, dan kemudian menyimpannya ke file lain.

$TLDs = Get-Content .\TLDsToSort-In.txt
$TLDStrings = @();

foreach ($TLD in $TLDs){
    $split = $TLD.split(".")
    [array]::Reverse($split)
    $TLDStrings += ,$split
}

$TLDStrings = $TLDStrings|Sort-Object

foreach ($TLD in $TLDStrings){[array]::Reverse($TLD)}

$TLDStrings | %{[string]::join('.', $_)} | Out-File .\TLDsToSort-Out.txt

Jalankan dengan 1.500 catatan - butuh 5 detik pada desktop yang cukup kuat.

cat domain.txt | rev | sortir | putaran

Sedikit kurang samar, atau setidaknya lebih cantik, Perl:

use warnings;
use strict;

my @lines = <>;
chomp @lines;

@lines =
    map { join ".", reverse split /\./ }
    sort
    map { join ".", reverse split /\./ }
    @lines;

print "$_\n" for @lines;

Ini adalah contoh sederhana dari transformasi Guttman-Rosler : kami mengubah garis menjadi bentuk yang dapat diurutkan yang sesuai (di sini, pisahkan nama domain pada periode dan membalik urutan bagian-bagian), mengurutkannya menggunakan jenis leksikografi asli dan kemudian mengonversi garis kembali ke bentuk aslinya.

Di skrip Unix: membalikkan, mengurutkan dan membalikkan:

awk -F "." '{for(i=NF; i > 1; i--) printf "%s.", $i; print $1}' file |
  sort |
  awk -F "." '{for(i=NF; i > 1; i--) printf "%s.", $i; print $1}'

Ini dia dalam perl (pendek dan samar):

#!/usr/bin/perl -w
@d = <>; chomp @d;
for (@d) { $rd{$_} = [ reverse split /\./ ] }
for $d (sort { for $i (0..$#{$rd{$a}}) {
        $i > $#{$rd{$b}} and return 1;
        $rd{$a}[$i] cmp $rd{$b}[$i] or next;
        return $rd{$a}[$i] cmp $rd{$b}[$i];
} } @d) { print "$d\n" }

awk -F"." 's="";{for(i=NF;i>0;i--) {if (i<NF) s=s "." $i; else s=$i}; print s}' <<<filename>>> | sort | awk -F"." 's="";{for(i=NF;i>0;i--) {if (i<NF) s=s "." $i; else s=$i}; print s}'

Apa yang dilakukan adalah membalik setiap diajukan dalam nama domain, mengurutkan dan membalikkan kembali.

Ini benar-benar mengurutkan daftar domain, berdasarkan leksikografis pada setiap bagian nama domain, dari kanan ke kiri.

Solusi terbalik ( rev <<<filename>>> | sort | rev), tidak, saya sudah mencobanya.