Classifique uma lista de nomes de domínio (FQDNs) iniciando em tld e trabalhando à esquerda

Estou procurando classificar uma lista de nomes de domínio (uma lista de permissões de filtro da Web) começando no TLD e trabalhando para cima. Estou procurando qualquer ferramenta * nix ou windows que possa fazer isso facilmente, embora um script também esteja bom.

Então, se esta é a lista que você recebe

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

É isso que eu quero como saída.

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

Caso você esteja se perguntando por que, Squidguard, tem uma falha de design / bug. Se ambos www.example.come ambos example.comestiverem incluídos em uma lista, a example.comentrada será ignorada e você poderá acessar apenas o conteúdo de www.example.com. Eu tenho várias listas grandes que precisam de limpeza porque alguém adicionou entradas sem olhar primeiro.

Este script python simples fará o que você deseja. Neste exemplo, nomeio o arquivo 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])

Para executá-lo, use:

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

Observe que isso parece um pouco mais feio, porque eu escrevi isso como uma linha simples, mais ou menos simples. Eu tive que usar a notação de fatia de[::-1] onde valores negativos funcionam para fazer uma cópia da mesma lista na ordem inversa, em vez de usar o mais declarativo reverse()que fá-lo no lugar de uma maneira que quebre a composição.

E aqui está uma versão um pouco mais longa, mas talvez mais legível que usa o reversed()que retorna um iterador, daí a necessidade de envolvê-lo list()para consumir o iterador e produzir uma lista:

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

Em um arquivo com 1.500 linhas classificadas aleatoriamente, leva ~ 0,02 segundos:

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

Em um arquivo com 150.000 linhas classificadas aleatoriamente, leva um pouco mais de 3 segundos:

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

Aqui está uma versão discutivelmente mais legível que funciona reverse()e sort()no local, mas é executada na mesma quantidade de tempo e, na verdade, requer um pouco mais de memória.

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

Em um arquivo com 1.500 linhas classificadas aleatoriamente, leva ~ 0,02 segundos:

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

Em um arquivo com 150.000 linhas classificadas aleatoriamente, leva um pouco mais de 3 segundos:

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

Aqui está um script do PowerShell que deve fazer o que você deseja. Basicamente, ele lança todos os TLDs em uma matriz, inverte cada TLD, classifica-o, inverte-o de volta à sua ordem original e o salva em outro arquivo.

$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

Executou 1.500 registros - levou 5 segundos em um desktop razoavelmente poderoso.

gato domain.txt | rev | classificar | rev

Um pouco menos enigmático, ou pelo menos mais bonito, Perl:

use warnings;
use strict;

my @lines = <>;
chomp @lines;

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

print "$_\n" for @lines;

Este é um exemplo simples de uma transformação de Guttman-Rosler : convertemos as linhas no formato classificável apropriado (aqui, dividimos o nome do domínio em períodos e invertemos a ordem das partes), classificá-las usando a classificação lexicográfica nativa e depois convertemos o linhas de volta à sua forma original.

Nos scripts Unix: reverse, sort e reverse:

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

Aqui está o perl (curto e enigmático):

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

O que isso faz é reverter cada arquivo no nome de domínio, classificar e retroceder.

Isso realmente classifica a lista de domínios, lexicograficamente com base em cada parte do nome do domínio, da direita para a esquerda.

A solução reversa ( rev <<<filename>>> | sort | rev), não, eu tentei.