vedoucí skupiny čísel mezi dvěma čísly

hlasů
-1

(Python) Vzhledem k tomu, dvě čísla A a B. musím najít všechny vnořené „skupiny“ čísel:

range(2169800, 2171194)

leading numbers: 21698XX, 21699XX, 2170XX, 21710XX, 217110X, 217111X, 
217112X, 217113X, 217114X, 217115X, 217116X, 217117X, 217118X, 2171190X, 
2171191X, 2171192X, 2171193X, 2171194X

nebo takto:

range(1000, 1452)

leading numbers: 10XX, 11XX, 12XX, 13XX, 140X, 141X, 142X, 143X, 
144X, 1450, 1451, 1452
Položena 08/06/2012 v 12:51
uživatelem
V jiných jazycích...                            


3 odpovědí

hlasů
0

To by mělo dát dobrý výchozí bod:

def leading(start, end):

    leading = []
    hundreds = start // 100

    while (end - hundreds * 100) > 100:
        i = hundreds * 100
        leading.append(range(i,i+100))
        hundreds += 1

    c = hundreds * 100
    tens = 1

    while (end - c - tens * 10) > 10:
        i = c + tens * 10
        leading.append(range(i, i + 10))
        tens += 1

    c += tens * 10
    ones = 1

    while (end - c - ones) > 0:
        i = c + ones
        leading.append(i)
        ones += 1

    leading.append(end)

    return leading

Ok, celé by mohlo být jedním loop-level hlouběji. Ale myslel jsem, že by mohlo být jasnější tímto způsobem. Doufat, že to pomůže vám ...

Aktualizace: Teď vidím, co chcete. Kromě toho, Mariin kód nezdá být práce pro mě. (Sorry ...) Takže prosím, na následující kód:

def leading(start, end):

    depth = 2
    while 10 ** depth > end : depth -=1
    leading = []
    const = 0
    coeff = start // 10 ** depth

    while depth >= 0:
        while (end - const - coeff * 10 ** depth) >= 10 ** depth:
            leading.append(str(const / 10 ** depth + coeff) + "X" * depth)
            coeff += 1

        const += coeff * 10 ** depth
        coeff = 0
        depth -= 1

    leading.append(end)

    return leading

print leading(199,411)

print leading(2169800, 2171194)

print leading(1000, 1453)

print leading(1,12)

Nyní mi dovolte, abych se snaží vysvětlit přístup zde. Algoritmus se pokusí najít „konec“, počínaje hodnotou „start“ a zkontrolujte, zda je „konec“ je v příštích 10 ^ 2 (což je 100 v tomto případě). Pokud selže, bude to dělat skok 10 ^ 2, dokud neproběhne úspěšně. Když se to podaří, že půjde o jeden stupeň nižší hloubky. To znamená, že to bude dělat skoky o řád menší. A smyčka, že způsob, jak do hloubky se rovná nule (= skoky 10 ^ 0 = 1). Algoritmus se zastaví, když se dosáhne hodnoty „End“.

Také si můžete všimnout, že jsem zavedený obtékání smyčku jsem se zmínil, takže je nyní možné definovat počáteční hloubku (nebo velikost skok) v proměnné.

První while zajišťuje, že první skok není překročení hodnoty „End“.

Máte-li jakékoli dotazy, jen neváhejte se zeptat.

Odpovězeno 08/06/2012 v 13:50
zdroj uživatelem

hlasů
0
def foo(start, end):
    index = 0
    is_lower = False
    while index < len(start):
        if is_lower and start[index] == '0':
            break
        if not is_lower and start[index] < end[index]:
            first_lower = index
            is_lower = True
        index += 1
    return index-1, first_lower


start = '2169800'
end = '2171194'
result = []
while int(start) < int(end):
    index, first_lower = foo(start, end)
    range_end = index > first_lower and 10 or int(end[first_lower])
    for x in range(int(start[index]), range_end):
        result.append(start[:index] + str(x) + 'X'*(len(start)-index-1))
    if range_end == 10:
        start = str(int(start[:index])+1)+'0'+start[index+1:]
    else:
        start = start[:index] + str(range_end) + start[index+1:]

result.append(end)
print "Leading numbers:"
print result

I test příklady, které jste dal, je to v pořádku. Doufám, že to pomůže

Odpovězeno 08/06/2012 v 14:27
zdroj uživatelem

hlasů
0

Těžší, než se poprvé podíval - jistá, že to je pevný a zvládne většinu okrajové podmínky. :) (Existuje jen velmi málo !!)

def leading(a, b):
    # generate digit pairs a=123, b=456 -> [(1, 4), (2, 5), (3, 6)]
    zip_digits = zip(str(a), str(b))
    zip_digits = map(lambda (x,y):(int(x), int(y)), zip_digits)

    # this ignores problems where the last matching digits are 0 and 9
    # leading (12000, 12999) is same as leading(12, 12)
    while(zip_digits[-1] == (0,9)):         
        zip_digits.pop()            

    # start recursion
    return compute_leading(zip_digits)

def compute_leading(zip_digits):
    if(len(zip_digits) == 1):   # 1 digit case is simple!! :)
        (a,b) = zip_digits.pop()
        return range(a, b+1)

    #now we partition the problem
    # given leading(123,456) we decompose this into 3 problems
    # lows    -> leading(123,129)
    # middle  -> leading(130,449) which we can recurse to leading(13,44)
    # highs   -> leading(450,456)

    last_digits = zip_digits.pop()
    low_prefix  = reduce(lambda x, y : 10 * x + y, [tup[0] for tup in zip_digits]) * 10     # base for lows e.g. 120
    high_prefix = reduce(lambda x, y : 10 * x + y, [tup[1] for tup in zip_digits]) * 10     # base for highs e.g. 450
    lows = range(low_prefix + last_digits[0], low_prefix + 10)
    highs = range(high_prefix + 0, high_prefix + last_digits[1] + 1)

    #check for boundary cases where lows or highs have all ten digits
    (a,b) = zip_digits.pop()    # pop last digits of middle so they can be adjusted
    if len(lows) == 10:
        lows = []
    else:
        a = a + 1

    if len(highs) == 10:
        highs = []
    else:
        b = b - 1

    zip_digits.append((a,b))    # push back last digits of middle after adjustments

    return lows + compute_leading(zip_digits) + highs       # and recurse - woohoo!!



print leading(199,411)

print leading(2169800, 2171194)

print leading(1000, 1452)
Odpovězeno 08/06/2012 v 14:43
zdroj uživatelem

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more