डोमेन नाम (FQDNs) की एक सूची को tld से शुरू करें और बाईं ओर काम करें

Question

मैं TLD से शुरू होने और ऊपर की ओर काम करने वाले डोमेन नामों की सूची (एक वेब फ़िल्टर व्हाइटेलिस्ट) को क्रमबद्ध करना चाह रहा हूँ। मैं किसी भी * निक्स या विंडोज़ टूल को देख रहा हूं जो आसानी से ऐसा कर सकता है, हालांकि एक स्क्रिप्ट भी ठीक होगी।

तो अगर आप दी गई सूची है

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

यह वही है जो मैं आउटपुट के रूप में चाहता हूं।

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

बस अगर आप सोच रहे हैं कि स्क्वीडगार्ड में बग / डिज़ाइन दोष क्यों है। यदि दोनों www.example.comऔर example.comदोनों एक सूची में शामिल हैं, तो example.comप्रविष्टि को नजरअंदाज कर दिया जाता है और आप केवल सामग्री देख सकते हैं www.example.com। मेरे पास कई बड़ी सूचियां हैं, जिन्हें कुछ सफाई की आवश्यकता है क्योंकि किसी ने पहली बार देखे बिना प्रविष्टियों को जोड़ा।

Comments

क्या comडोमेन eduको आपकी छँटाई सूची में पहले नहीं दिखाया जाना चाहिए ?

— स्वेन

हाँ, मैं मैनुअल छँटाई में विफल रहता हूँ, यही वजह है कि मैं एक उपकरण की तलाश कर रहा हूँ। :)

— 2

का धोखा stackoverflow.com/questions/342590/sorting-domain-names ?

— मार्क वैगनर

इसके अलावा, पायथन संस्करण वहाँ पर्ल संस्करण की तुलना में अच्छा है क्योंकि अजगर की तरह सूचियों की सूची पर काम करता है; पर्ल के प्रकार को लागू नहीं किया गया था और इसे लागू नहीं किया गया था।

— मार्क वैगनर

एक ओर ध्यान दें तो यह अधिक चुनौतीपूर्ण होगा यदि ओपी ने मोज़िला के सार्वजनिक प्रत्यय ( publicsuffix.org ) के अनुसार शीर्ष-डोमेन के लिए एक ब्लॉक के रूप में सूची मांगी थी । मैं किसी भी बिंदु पर इसे करने के लिए आ सकता हूं (यह एक परियोजना के लिए अच्छा होगा), किसी और को दिलचस्पी है?

— phk

Answer 1

यह सरल अजगर स्क्रिप्ट वह करेगी जो आप चाहते हैं। इस उदाहरण में मैंने फ़ाइल का नाम दिया है 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])

इसे चलाने के लिए उपयोग करें:

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

ध्यान दें कि यह थोड़ा बदसूरत दिखता है क्योंकि मैंने इसे अधिक या कम एक साधारण लाइनर के रूप में लिखा था मुझे स्लाइस अंकन का[::-1] उपयोग करना था जहां नकारात्मक मूल्य अधिक घोषणा का उपयोग करने के बजाय रिवर्स ऑर्डर में उसी सूची की एक प्रति बनाने के लिए काम करते हैंreverse() जो इसे एक तरह से इन-प्लेस करता है जो कंपोजिबिलिटी को तोड़ता है।

और यहाँ थोड़ा लंबा है, लेकिन शायद अधिक पठनीय संस्करण जो उपयोग करता है reversed()जो एक पुनरावृत्ति देता है, इसलिए इसे list()पुनरावृत्ति करने के लिए इसे लपेटने और सूची बनाने के लिए भी आवश्यकता होती है :

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

1,500 यादृच्छिक रूप से सॉर्ट की गई लाइनों वाली फाइल पर ~ 0.02 सेकंड का समय लगता है:

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

150,000 बेतरतीब ढंग से छांटे गए फ़ाइल पर यह 3 सेकंड से थोड़ा अधिक लगता है:

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

यहाँ है कि एक यकीनन अधिक पठनीय संस्करण है reverse()और sort()यथा-स्थान है, लेकिन यह उतना ही समय में चलाता है, और वास्तव में थोड़ा और अधिक स्मृति लेता है।

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

1,500 यादृच्छिक रूप से सॉर्ट की गई लाइनों वाली फाइल पर ~ 0.02 सेकंड का समय लगता है:

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

150,000 बेतरतीब ढंग से छांटे गए फ़ाइल पर यह 3 सेकंड से थोड़ा अधिक लगता है:

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

Comments

मुझे बहुत सारे समाधान देखकर अच्छा लगा। मैं अजगर आधारित उत्तर को ज्यादातर स्वीकार कर रहा हूं क्योंकि यह वह है जो मैं अपनी कई अन्य लिपियों के लिए उपयोग करता हूं। अन्य उत्तर सभी काम करने लगते हैं।

— ज़ोराचे

यदि किसी को पहले डोमेन नाम से छांटने में दिलचस्पी है, तो TLD को अनदेखा करते हुए, उपयोग करेंdata.sort(key=lambda x: x[1:])

— Calimo

Answer 2

यहाँ एक PowerShell स्क्रिप्ट है जो आपको चाहिए वह करना चाहिए। मूल रूप से यह सभी TLD को फेंकता है एक सरणी में प्रत्येक TLD को उलट देता है, इसे सॉर्ट करता है, इसे अपने मूल क्रम में वापस लाता है और फिर इसे किसी अन्य फ़ाइल में सहेजता है।

$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

1,500 रिकॉर्ड्स पर दौड़ा - एक यथोचित शक्तिशाली डेस्कटॉप पर 5 सेकंड।

Comments

मुझे इस स्क्रिप्ट को बैश या किसी अन्य भाषा में बदलने में काफी सरल होना चाहिए जो मुझे लगता है।

— मार्क हेंडरसन

5 सेकंड केवल 1,500 लाइनों के लिए एक लंबे समय की तरह लगता है। मेरे अजगर का कार्यान्वयन एक सेकंड के एक हिस्से में 1,500 करता है, और केवल 3 सेकंड में 150,000। आपको क्या लगता है कि यह PowerShell में इतना धीमा है?

— aculich

हाँ, यह एक लंबा समय है। मुझे पता नहीं क्यों यह इतना समय लगता है। शायद इसलिए कि पॉवरशेल वास्तव में इस तरह की चीजें करने के उद्देश्य से नहीं है।

— मार्क हेंडरसन

Answer 3

cat domain.txt | रेव | सॉर्ट | फिरना

Comments

मुझे लगता है कि काम करेगा। मुझे लगता है कि TLD होने की तरह है, और यह पूरा नहीं होगा। इसका उपयोग करते हुए, मेरे उदाहरण में TLD क्रम में होगा (uk, mil, pl, com, edu, gov) क्योंकि यह डोमेन सीमाओं के बजाय, बाएं से छांटने का एक सरल अधिकार है।

— ज़ोदाचेस

सबसे अच्छा जवाब मैंने देखा है!

— डैनियल

rev domain.txt|sort|rev

— रिच

Answer 4

थोड़ा कम गूढ़, या कम से कम सुंदर, पर्ल:

use warnings;
use strict;

my @lines = <>;
chomp @lines;

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

print "$_\n" for @lines;

यह गुटमैन-रोस्लर ट्रांसफ़ॉर्म का एक सरल उदाहरण है : हम लाइनों को उचित सॉर्टेबल रूप में परिवर्तित करते हैं (यहां, समय पर डोमेन नाम को विभाजित करें और भागों के क्रम को उल्टा करें), उन्हें मूल लेक्सोग्राफ़िक सॉर्ट का उपयोग करके सॉर्ट करें और फिर कनवर्ट करें वापस अपने मूल रूप में।

Answer 5

यूनिक्स स्क्रिप्टिंग में: रिवर्स, सॉर्ट और रिवर्स:

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

Comments

सिंगल लूप के साथ भी ऐसी ही बात: awk -F. '{for(i=NF;i>0;i--){printf ".%s",$i};printf "\t%s\n",$0}' file|sort|cut -f2हो सकता है कि लोकल होस्ट्स को पहले बाहर कर दिया जाएgrep \. file | awk ...

— रिच '

Answer 6

यहाँ यह (छोटी और गुप्त) प्रति है:

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

Comments

क्या आपके पास इस प्रकार के लिए समय की जानकारी है? मैं यह देखने के लिए उत्सुक हूं कि यह @ मार्क-हेंडरसन के पॉवरशेल कार्यान्वयन के साथ-साथ मेरे पायथन कार्यान्वयन की तुलना कैसे करता है । मैं /usr/bin/time -vबीता हुआ समय और अधिकतम मेमोरी आँकड़ों के लिए इस्तेमाल किया ।

— अकुलिच

ऑबफसेशन पर पर्ल पूरी तरह से जीतता है।

— मैसिमो

एक पर्ल स्क्रिप्ट को "संक्षिप्त और गूढ़" के रूप में वर्णन करना बेमानी है।

— बेलमिन फर्नांडीज

@aculich, पॉवरशेल स्क्रिप्ट के अपवाद के साथ, सभी विकल्प मेरी फ़ाइल पर 0.1 सेकंड कम लगते हैं।

— Zoredache

Answer 7

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

यह क्या डोमेन नाम में दर्ज प्रत्येक को उल्टा करने के लिए है, सॉर्ट और वापस उल्टा।

यह वास्तव में डोमेन सूची, लेक्सिकोग्राफ़िक रूप से डोमेन-नाम के प्रत्येक भाग पर आधारित है, दाएं से बाएं।

रिवर्स सॉल्यूशन ( rev <<<filename>>> | sort | rev), नहीं, मैंने कोशिश की है।