18 votos

Ordenar una lista de nombres de dominio (FQDN) a partir de tld y trabajando izquierda

Estoy buscando para ordenar una lista de nombres de dominio (una web de filtro de lista blanca) a partir de la TLD y trabajando hacia arriba. Estoy buscando cualquier *nix o herramientas de windows que pueden hacer esto fácilmente, a pesar de un guión estaría bien también.

Así que si el es la lista que se da

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

Esto es lo que quiero como a la salida.

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

Sólo en caso de que usted se está preguntando por qué, Squidguard, tiene un bug/error de diseño. Si tanto www.example.com y example.com , están incluidos en una lista, a continuación, el example.com de entrada se ignora y sólo se puede visitar el contenido de www.example.com. Tengo varias listas de gran tamaño que necesita algo de limpieza porque alguien ha añadido entradas sin mirar primero.

13voto

aculich Puntos 1730

Este simple script en python hace lo que usted desea. En este ejemplo, el nombre del archivo 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 ejecutarlo uso:

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

Tenga en cuenta que este se ve un poco feo desde que escribí esto como más o menos un simple one-liner tuve que usar la notación de segmentos de [::-1] , donde los valores negativos trabajo para hacer una copia de la misma lista en orden inverso, en lugar de utilizar el más declarativo reverse() que lo hace en lugar de en una manera que rompe el composability.

Y aquí un poco más de tiempo, pero tal vez la versión más legible que utiliza reversed() que devuelve un iterador, de ahí también la necesidad de envolverlo en list() a consumir el iterador y producir una 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)))

En un archivo con más de 1.500 ordenados aleatoriamente líneas se tarda ~0,02 segundos:

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

En un archivo con 150.000 ordenados aleatoriamente líneas se tarda un poco más de 3 segundos:

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

Aquí es, sin duda, más legible versión que hace de la reverse() y sort() en el lugar, pero se ejecuta en la misma cantidad de tiempo, y en realidad tiene un poco más de memoria.

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

En un archivo con más de 1.500 ordenados aleatoriamente líneas se tarda ~0,02 segundos:

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

En un archivo con 150.000 ordenados aleatoriamente líneas se tarda un poco más de 3 segundos:

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

9voto

Shlomi Fish Puntos 1951

Aquí es un script de PowerShell que debe hacer lo que quieras. Básicamente lanza todos los TLD en una matriz invierte cada TLD, clases, lo invierte a su orden original y luego guarda en otro archivo.

$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

Funcionó en 1.500 expedientes - tardó 5 segundos en un escritorio razonablemente potente.

6voto

Ilmari Karonen Puntos 144

Ligeramente menos críptico, o al menos más bonita, 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 es un ejemplo simple de una Guttman – Rosler transformar: convertir las líneas en la forma apropiada puede ordenar (partido aquí, el nombre de dominio en períodos e invertir el orden de las partes), ordenarlos utilizando la clase nativa lexicográfica y luego convertir las líneas de vuelta a su forma original.

6voto

jfgagne Puntos 796

En secuencias de comandos de Unix: invertir, ordenar e invertir:

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

3voto

Mark Wagner Puntos 11107

Aquí está en perl (corto y críptico):

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

EnMiMaquinaFunciona.com

EnMiMaquinaFunciona es una comunidad de administradores de sistemas en la que puedes resolver tus problemas y dudas.
Puedes consultar las preguntas de otros sysadmin, hacer tus propias preguntas o resolver las de los demás.

Powered by: