Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/python3
# -*- coding: utf-8 -*-



class Mathe_Functions(object):
    def __init__(self):
        super(Mathe_Functions, self).__init__()
        # Zahl hat mindestens eine Stelle
        self.stellen = 1

    def anzahl_ziffern(self, zahl):
        # die Anzahl der Stellen von der Zahl ermitteln
        anzahl = 1
        while zahl >= 10:
            zahl /= 10
            anzahl += 1
        return anzahl
     
    def quersumme(self, zahl):
        # Quersumme der Zahl bilden
        stellen = self.anzahl_ziffern(zahl)
        summe = 0
        while stellen > 0:
            summe += zahl % 10
            zahl = (zahl - zahl % 10) / 10
            stellen -= 1
        return int(summe)

    def stellen_kuerzen(self, zahl, kuerzen = 1):
        # Zahl um x Stellen kuerzen (standard eine Stelle)
        # dabei muss die Zahl mindestens x Stellen lang 'self.stellen' sein
        stellen = self.anzahl_ziffern(zahl)
        if stellen - self.stellen >= kuerzen:
            zahl = zahl % 10**(stellen-kuerzen)
        return zahl

    def zahl_links_shiften(self, zahl, einer):
        # Zahl um eine Stelle nach Links verschieben 
        zahl *= 10
        zahl += einer
        zahl = self.stellen_kuerzen(zahl, 1)
        return zahl

    def letzte_zahl(self, zahl):
        # die letzte Ziffer der Zahl ermitteln 
        if zahl >= 10:
            return zahl % 10
        return zahl

 
class Code_X_Stellig(Mathe_Functions):
    def __init__(self, stellen):
        super(Code_X_Stellig).__init__()
        self.stellen = stellen
        self.codes = {}
        self.groups = []
    
    def __str__(self):
        liste = [int(zahl) for zahl in self.codes]
        liste.sort()
        for code in liste:
            tage = str(self.codes[str(code)]['tage']).ljust(4)
            code_string = ('000'+str(code))[-4:]
            print("Code: %s Tage: %s Gruppe: %i" % (code_string, tage, self.codes[str(code)]['gruppe']))

        return ''

    def auswertung(self):
        gruppen_anzahl = len(self.groups)
        kombinationen = set()
        ohne_wiederkehr = []
        for code in self.codes:
            kombinationen.add(self.codes[code]['tage'])
            if self.codes[code]['tage'] == -1:
                ohne_wiederkehr.append(code)
        print("Es existieren %i unterschiedliche Gruppierungen" % gruppen_anzahl)
        print("Folgende Komibnationen traten dabei auf: %s" % kombinationen)
        print("Folgende Zahlen kehren nie wieder zurück: %s" % ohne_wiederkehr)

    def recheck_groups(self):
        liste = [int(zahl) for zahl in self.codes]
        liste.sort()
        for zahl in liste:
            for nr, group in enumerate(self.groups):
                if zahl in group:
                    self.codes[str(zahl)]['gruppe'] = nr
                    break
        
    def add_group(self, zahl, liste):
        gefunden = False
        for group in self.groups:
            if zahl in group:
                gefunden = True
                break

        if not gefunden:
            self.groups.append(liste)
    
    def mathe(self, ur_code):
        # nach wievielen durchlaeufen kommt die zahl wieder vor
        # bedingung:  1. links-shiften um eine Stelle 
        #             2. quersumme (einer-stelle) anhaengen
        code = ur_code
        tage = 0
        zahlen_liste = []
        while tage < 10000:
            summe = self.quersumme(code)
            zahl = self.letzte_zahl(summe)
            code = self.zahl_links_shiften(code, zahl)
            zahlen_liste.append(code)
            tage += 1
            if code == ur_code:
                break
        if tage == 10000: tage = -1
        return tage, zahlen_liste
    
    def experimental(self, zahlen_liste, tage):
        # da der vorige Code nach X Durchlaeufen wiederkehrt, 
        # kehren auch alle Zahlen in der zahlen_liste nach diesen X Durchlaeufen wieder
        for zahl in zahlen_liste:
            sammeln.codes[str(zahl)] = {'tage' : tage, 'gruppe': -1}

if __name__ == '__main__':

    stellen = 4
    sammeln = Code_X_Stellig(stellen)
    # tage, zahlen_liste = sammeln.mathe(1986)
    # print("Es vergehen %i Tage, bis sich der Code %i wiederholt!" % (tage, 1986))

    for code in range(1,10000):
        if not str(code) in sammeln.codes:
            tage, zahlen_liste = sammeln.mathe(code)
            sammeln.codes[str(code)] = {'tage' : tage, 'gruppe': -1}
            sammeln.add_group(code, zahlen_liste)
            sammeln.experimental(zahlen_liste, tage)
    
    sammeln.recheck_groups()
    # print(sammeln)
    sammeln.auswertung()

Code: Alles auswählen

) return false;
        is_code_used[code] = true;
        ++day;
    } while (code != start_code);
    *days = day;
    return true;
}

int main(void)
{
    uint16_t start_code;
    uint16_t days;
    
    puts("start_code,days");
    for (start_code = 0; start_code <= 9999; ++start_code) {
        if (calculate_days(start_code, &days)) {
            printf("%04u,%u\n", start_code, days);
        } else {
            printf("%04u,inf\n", start_code);
        }
    }

    return 0;
}

Code: Alles auswählen

class Code(object):
    def __init__(self, laenge, zahl = -1):
        self._generation = 0
        self.laenge = laenge
        if zahl >= 0: 
            self.ziffern = list(map(int, str(zahl)))
        else:
            self.ziffern = [random.randint(0,9) for x in laenge]
        self.codes = [self.get_code()]

    def next_code(self, generations = 1):
        while generations > 0:
            zahl = sum(self.ziffern) % 10        
            self.ziffern.append(zahl)
            self.ziffern = self.ziffern[self.laenge*-1:]
            self._generation += 1
            self.codes.append(self.get_code())
            generations -= 1
        return self.get_code()

    def get_code(self):
        return int(''.join(map(str, self.ziffern)))
    
    def get_codes(self):
        return self.codes

    def get_generation(self):
        return self._generation

    def show_generations(self, von=0, bis=None):
        text = ''
        if not bis: bis = self._generation
        for generation in range(von, bis + 1):
            text += "Gen: %s - %i\n" % (generation, self.codes[generation])
        return text
    
    def __str__(self):
        return "Code: %4d - Generation: %i" % (self.get_code(), self._generation)

class CodeGruppe(object):
    def __init__(self):
        self.gruppen = []
        self._codes = []

    def add_group(self, codes):
        if not self.number_exists(codes[0]):
            self.gruppen.append(codes)
            self._codes.extend(codes)
    
    def number_exists(self, code):
        if code in self._codes:
            return True
        return False
    
    def get_group(self, number):
        return self.gruppen[number]

    def get_group_number(self, code):
        if not code in self._codes:
            return False
        for nr in self.get_group_numbers():
            if code in self.gruppen[nr]:
                return nr
    
    def get_group_numbers(self):
        return [nr for nr, liste in enumerate(self.gruppen)]

    def get_group_info(self, *arg):
        text = ''
        if not arg:
            arg = self.get_group_numbers()
        for nr in arg:
            text += "Gruppe: %i laenge: %i\n" % (nr, len(self.gruppen[nr]))

        return text

def main():
    codegruppe = CodeGruppe()

    for i in range(0, 1000):
        if not codegruppe.number_exists(i):
            code = Code(4, i)
            anfang = code.get_code()

            while code.get_generation() < 4800:
                if anfang == code.next_code():
                    break
            codegruppe.add_group(code.get_codes())
    
    
    print(codegruppe.get_group_info())
    number = codegruppe.get_group_number(1986)
    print(codegruppe.get_group_info(number))
    print(codegruppe.get_group(number))

if __name__ == '__main__':
    main()

Code: Alles auswählen

In [13]: '%0*d' % (4, 42)
Out[13]: '0042'

In [14]: '{0:0{1}d}'.format(42, 4)
Out[14]: '0042'

In [15]: str(42).zfill(4)
Out[15]: '0042'

Code: Alles auswählen

    def add_group(self, zahl, liste):
        gefunden = False
        for group in self.groups:
            if zahl in group:
                gefunden = True
                break
 
        if not gefunden:
            self.groups.append(liste)

Code: Alles auswählen

    def add_group(self, zahl, liste):
        if all(zahl not in group for group in self.groups):
            self.groups.append(liste)

Code: Alles auswählen

In [21]: isinstance(False, int)
Out[21]: True

In [22]: False == 0
Out[22]: True

In [23]: False + 42
Out[23]: 42

In [24]: False * 42
Out[24]: 0

Code: Alles auswählen

#!/usr/bin/env python
from __future__ import absolute_import, division, print_function


def get_cross_sum(number):
    result = 0
    while number:
        number, digit = divmod(number, 10)
        result += digit
    return result


def code_as_string(code_length, code_value):
    return str(code_value).zfill(code_length)


def shifted_code(code_length, code_value, digit):
    return code_value * 10 % 10**code_length + digit


def get_next_code(code_length, code_value):
    return shifted_code(code_length, code_value, get_cross_sum(code_value) % 10)


def calculate_days(code_length, start_code_value):
    days = 0
    code_value = start_code_value
    while True:
        days += 1
        code_value = get_next_code(code_length, code_value)
        if code_value == start_code_value:
            return days


def main():
    code_length = 4
    for code_value in range(10**code_length):
        print(
            code_as_string(code_length, code_value),
            calculate_days(code_length, code_value)
        )


if __name__ == '__main__':
    main()

Code: Alles auswählen

Code = namedtuple('Code', 'length value')


def code_as_string(code):
    return str(code.value).zfill(code.length)


def shifted_code(code, digit):
    return Code(code.length, code.value * 10 % 10**code.length + digit)


def get_next_code(code):
    return shifted_code(code, get_cross_sum(code.value) % 10)


def calculate_days(start_code):
    days = 0
    code = start_code
    while True:
        days += 1
        code = get_next_code(code)
        if code == start_code:
            return days


def iter_codes(length):
    return (Code(length, i) for i in range(10**length))


def main():
    length = 4
    for code in iter_codes(length):
        print(code_as_string(code), calculate_days(code))

Code: Alles auswählen

class Code(namedtuple('Code', 'length value')):

    def __str__(self):
        return str(self.value).zfill(self.length)

    def shifted(self, digit):
        return Code(self.length, self.value * 10 % 10**self.length + digit)

    def get_next(self):
        return self.shifted(get_cross_sum(self.value) % 10)

    @classmethod
    def iter_all(cls, length):
        return (cls(length, i) for i in range(10**length))


def calculate_days(start_code):
    days = 0
    code = start_code
    while True:
        days += 1
        code = code.get_next()
        if code == start_code:
            return days


def main():
    length = 4
    for code in Code.iter_all(length):
        print(code, calculate_days(code))

Code: Alles auswählen

from itertools import product
from collections import Counter

alle = set(product(range(10),repeat=4))
seen = set()

def next_code(code):
    return code[1:] + (sum(code) % 10,)

def main():
    ringcounter = Counter()
    for code in alle:
        if code in seen:
            continue
        codering = []
        start = code[:]
        c = 0
        while True:
            code = next_code(code)
            codering.append(code)
            c+=1
            if code == start:
                break:
        seen.update(codering)
        ringcounter[c] += 1
    kontrolle = 0
    for key, value in ringcounter.items():
        kontrolle += key * value
        print( "{} Codereihen aus {} Codes".format(value, key))
    print("kontrollsumme ist {}".format(kontrolle))
                
            
main()

Code: Alles auswählen

from itertools import product
from collections import Counter

def next_code(code):
    return code[1:] + (sum(code) % 10,)        

def main():
    pool = set(product(range(10),repeat=4))
    ringcounter = Counter()    
    while pool:
        code = pool.pop()
        codering = []
        start = code[:]
        c = 0
        while True:
            code = next_code(code)
            codering.append(code)
            c += 1
            if code == start:
                break
        pool = pool.difference(codering)
        ringcounter[c] += 1
            
    kontrolle = 0
    for key, value in ringcounter.items():
        kontrolle += key * value
        print( "{} Codereihen aus {} Codes".format(value, key))
    print("kontrollsumme ist {}".format(kontrolle))

Code: Alles auswählen

from itertools import product
from collections import Counter

def iter_code(code): 
    nextcode = code
    while True:
        nextcode = nextcode[1:] + (sum(nextcode) % 10,)
        if code == nextcode:
            return
        yield nextcode        

def main():
    pool = set(product(range(10),repeat=4))
    ringcounter = Counter()    
    while pool:
        code = pool.pop()
        codering = [code]
        for icode in iter_code(code):
            codering.append(icode)
        pool = pool.difference(codering)
        ringcounter[len(codering)] += 1
            
    kontrolle = 0
    for key, value in ringcounter.items():
        kontrolle += key * value
        print( "{} Codereihen aus {} Codes".format(value, key))
    print("kontrollsumme ist {}".format(kontrolle))

Code: Alles auswählen

from itertools import count
from collections import deque

def count_days(code):
    digits = deque(map(int, code), len(code))
    old = deque(digits)
    for num_days in count(1):
        digits.append(sum(digits) % 10)
        if digits == old:
            return num_days

def main():
    num_days = count_days('1986')
    print('Code wiederholt sich nach', num_days, 'Tagen.')

if __name__ == '__main__':
    main()