अक्षरांकीय तार उत्पन्न क्रमिक रूप से

Question

मैं इस प्रकार एक पाश बनाने के लिए पैदा करते हैं और प्रिंट तार करने के लिए कोशिश कर रहा हूँ:

1. अक्षरांकीय केवल अक्षर:
2. 0-9 जो az से पहले कर रहे हैं, AZ से पहले कर रहे हैं,
3. लंबाई 4 अक्षरों तक जाती है।

तो, इसे प्रिंट होगा:

1. सभी स्ट्रिंग्स 0-z से
2. तो 00-ZZ
3. से तो 000-zzz
4. फिर से 0000-ZZZZ से

तो यह बंद हो जाता है।

Answer 1

from string import digits, ascii_uppercase, ascii_lowercase 
from itertools import product 

chars = digits + ascii_uppercase + ascii_lowercase 

for n in range(1, 4 + 1): 
    for comb in product(chars, repeat=n): 
     print ''.join(comb) 

यह पहले सभी संख्याओं, अपरकेस अक्षरों और लोअरकेस अक्षरों की एक स्ट्रिंग बनाता है।

फिर, प्रत्येक लंबाई के लिए 1-4 से, यह उन संख्याओं और अक्षरों के हर संभव संयोजन को प्रिंट करता है। मन में

रखें इस संयोजन के बहुत है - 62^4 + 62^3 + 62^2 + 62.

Answer 2

मैं अजगर में इसके कार्यान्वयन को देख के बाद से मेरे सामने दिए गए जवाब product का उपयोग कर नापसंद प्रलेखन यह परिणाम उत्पन्न करने से पहले स्मृति में पूरी चीज को स्मृति में एक सूची में फैलाता प्रतीत होता है।

एएफएफ ने स्वयं कहा है कि यह आपके मामले के लिए बहुत बुरा है, क्योंकि यहां पर क्रमपरिवर्तन की संख्या बहुत बड़ी है (एक मिलियन से अधिक)। इस मामले के लिए yield कथन बनाया गया था - ताकि स्मृति में फैले हुए विशाल सूची को गतिशील रूप से उत्पन्न किया जा सके (मुझे अपमानजनक range भी नापसंद किया गया जहां xrange पूरी तरह से लागू है)।

मैं इस तरह के समाधान के लिए जाना चाहते हैं:

def generate(chars, length, prefix = None): 
    if length < 1: 
     return 
    if not prefix: 
     prefix = '' 
    for char in chars: 
     permutation = prefix + char 
     if length == 1: 
      yield permutation 
     else: 
      for sub_permutation in generate(chars, length - 1, prefix = permutation): 
       yield sub_permutation 

इस तरह, वह सब याद में फैला हुआ है एक पुनरावर्ती ढेर है "n" गहरी, जहां "n" अपने क्रमपरिवर्तन की लंबाई है (4 इस मामले में) और हर बार केवल एक ही तत्व लौटाया जाता है।

वर्ण चुनने के लिए वर्णों का सेट है, लंबाई 4 है और उपयोग उत्पादों के समान ही है, सिवाय इसके कि यह रन टाइम के दौरान स्मृति में पूरी सूची नहीं फैलता है।

Answer 3

मैंने आज इसे कोड किया। यह वही करता है जो आप और अधिक चाहते हैं। यह

def lastCase (lst): 
    for i in range(0, len(lst)): 
     if (lst[i] != '_'): 
      return False 
    return True 


l = [''] * 4 #change size here if needed. I used 4 
l[0] = '0' 
index = 0 

while (not lastCase(l)): 

    if (ord(l[index]) > ord('_')): 
     l[index] = '0' 
     index += 1 
     while(l[index] == '_'): 
      l[index] = '0' 
      index += 1 
     if (l[index] == ''): 
      l[index] = '0' 

    #print or process generated string 
    print(''.join(l)) 

    l[index] = chr(ord(l[index]) +1) 

    if (ord(l[index]) > ord('9') and ord(l[index]) < ord('A')): 
     l[index] = 'A' 
    elif (ord(l[index]) > ord('Z') and ord(l[index]) < ord('_') ): 
     l[index] = '_' 

    index = 0 

print (''.join(l))