Trier une liste de noms de domaine (FQDN) en commençant par tld et en travaillant à gauche

Je cherche à trier une liste de noms de domaine (une liste blanche de filtres Web) à partir du TLD et en remontant. Je recherche des outils * nix ou windows qui peuvent le faire facilement, même si un script conviendrait également.

Donc, si c'est la liste qui vous est donnée

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

C'est ce que je veux comme sortie.

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

Juste au cas où vous vous demandez pourquoi Squidguard a un défaut de conception / bug. Si les deux www.example.comet example.comsont tous deux inclus dans une liste, l' example.comentrée est ignorée et vous ne pouvez visiter que le contenu de www.example.com. J'ai plusieurs grandes listes qui nécessitent un nettoyage, car quelqu'un a ajouté des entrées sans regarder en premier.

Ce simple script python fera ce que vous voulez. Dans cet exemple, je nomme le fichier 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])

Pour l'exécuter, utilisez:

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

Notez que cela semble un peu plus laid depuis que j'ai écrit cela comme plus ou moins un simple simple, j'ai dû utiliser la notation par tranche d'[::-1] où les valeurs négatives fonctionnent pour faire une copie de la même liste dans l'ordre inverse au lieu d'utiliser le plus déclaratif reverse()qui le fait en place d'une manière qui rompt la composabilité.

Et voici une version légèrement plus longue, mais peut-être plus lisible qui utilise reversed()qui retourne un itérateur, d'où la nécessité de l'envelopper également list()pour consommer l'itérateur et produire une liste:

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

Sur un fichier avec 1 500 lignes triées aléatoirement, cela prend ~ 0,02 seconde:

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

Sur un fichier avec 150 000 lignes triées aléatoirement, cela prend un peu plus de 3 secondes:

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

Voici une version sans doute plus lisible qui fait le reverse()et sort()en place, mais elle s'exécute dans le même temps et prend en fait un peu plus de mémoire.

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

Sur un fichier avec 1 500 lignes triées aléatoirement, cela prend ~ 0,02 seconde:

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

Sur un fichier avec 150 000 lignes triées aléatoirement, cela prend un peu plus de 3 secondes:

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

Voici un script PowerShell qui devrait faire ce que vous voulez. Fondamentalement, il jette tous les TLD dans un tableau inverse chaque TLD, le trie, le ramène à son ordre d'origine, puis l'enregistre dans un autre fichier.

$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

Il a fonctionné sur 1 500 enregistrements - a pris 5 secondes sur un bureau raisonnablement puissant.

cat domain.txt | rev | trier | tour

Perl légèrement moins crypté, ou du moins plus joli:

use warnings;
use strict;

my @lines = <>;
chomp @lines;

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

print "$_\n" for @lines;

Voici un exemple simple de transformation de Guttman – Rosler : nous convertissons les lignes dans la forme triable appropriée (ici, divisons le nom de domaine par périodes et inversons l'ordre des parties), trions-les en utilisant le tri lexicographique natif, puis convertissons le lignes à leur forme d'origine.

Dans les scripts Unix: inversez, triez et inversez:

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}'

Le voici en (court et cryptique) perl:

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

Cela revient à inverser chaque fichier du nom de domaine, à trier et à inverser.

Cela trie vraiment la liste des domaines, lexicographiquement en fonction de chaque partie du nom de domaine, de droite à gauche.

La solution inverse ( rev <<<filename>>> | sort | rev), non, je l'ai essayée.