[PYTHON] Code basé sur zéro, le rendement du kata et la séquence de Fibonacci

Au codewars kata, vous pouvez apprendre la programmation et l'anglais pratique en même temps. Si vous avez un compte github, vous pouvez commencer en 30 secondes Si vous êtes intéressé, commencez ici maintenant

En passant, vous pouvez défier dans de nombreux langages autres que python

Q1.https://www.codewars.com/kata/54d512e62a5e54c96200019e/train/python

Given a positive number n > 1 find the prime factor decomposition of n. The result will be a string with the following form :

 "(p1**n1)(p2**n2)...(pk**nk)"
with the p(i) in increasing order and n(i) empty if n(i) is 1.

Example: n = 86240 should return "(2**5)(5)(7**2)(11)"

Étant donné un entier positif n, renvoie les nombres premiers qui le composent

my A.

def primeFactors(b ):

    ps = []
    ns = []
    i = 1
    while  not b==1:
        i += 1
        j = 0
        while not b % i:
            b = b / (i)
            j += 1
        if not j == 0:        
            ps.append(i)
            ns.append(j)
            
    return ''.join([ '({})'.format(p) if  n == 1 else '({}**{})'.format(p,n) for p,n in zip(ps,ns)])
   

3000ms

Première tentative réussie

def primeFactors(b ):

    k = 100000000000000
    ps = []
    ns = []
    
    for i in range(2,k):
        mod = 0    
        j = 0
        if b ==1:
            break
        while mod == 0:
            div,mod = divmod(b,i)
            if mod == 0:
                b = b / (i)
                j += 1
        if not j == 0:        
            ps.append(i)
            ns.append(j)
            
    return ''.join([ '({})'.format(p) if  n == 1 else '({}**{})'.format(p,n) for p,n in zip(ps,ns)])

5500ms

Best Answer

def primeFactors(n):
    ret = ''
    for i in range(2, n + 1):
        num = 0
        while(n % i == 0):
            num += 1
            n /= i
        if num > 0:
            ret += '({}{})'.format(i, '**%d' % num if num > 1 else '')
        if n == 1:
            return ret

3000ms Je sauvegarde le résultat sous forme de liste → pour une chaîne Ceci est une chaîne de caractères du début Le temps d'exécution est presque le même, mais lequel est le meilleur?

Q2.https://www.codewars.com/kata/559a28007caad2ac4e000083/solutions/python

The drawing shows 6 squares the sides of which have a length of 1, 1, 2, 3, 5, 8. It's easy to see that the sum of the perimeters of these squares is : 4 * (1 + 1 + 2 + 3 + 5 + 8) = 4 * 20 = 80

Could you give the sum of the perimeters of all the squares in a rectangle when there are n + 1 squares disposed in the same manner as in the drawing:

Trouvez quatre fois la somme de la séquence de Fibonacci

my A.https://www.codewars.com/kata/559a28007caad2ac4e000083/train/python

def perimeter(n):
    # your code
    fibo = [1,1]
    for i in range(n-1):
        fibo.append(fibo[-1] + fibo[-2] )
    return sum(fibo)*4

best A1.

def fib(n):
    a, b = 0, 1

    for i in range(n+1):
        if i == 0:
            yield b 
        else:
            a, b = b, a+b
            yield b
        

def perimeter(n):
    return sum(fib(n)) * 4

yield est une instruction qui a pour fonction d'arrêter temporairement l'exécution d'une fonction. En utilisant yield au lieu de return, vous pouvez retourner les éléments un par un sans les stocker dans une liste, etc. Qu'est-ce que ça veut dire

length = 5
generator  =fib(length)
for i in range(length):
    print(next(generator),end=', ')

out

1, 1, 2, 3, 5, 

De cette manière, la boucle for de la fonction peut être arrêtée à mi-chemin et la valeur peut être renvoyée. Il semble que cette somme soit prise. Pour plus de détails, voir Site de commentaires etc.

best A2.

def perimeter(n):
    a, b = 1, 2
    while n:
        a, b, n = b, a + b, n - 1
    return 4 * (b - 1)

Cela signifie qu'il semble utiliser cette formule

Je vais essayer de dériver La seule formule que j'utilise le plus est $ a_ {k} = a_ {k-1} + a_ {k-2} $ ... Pensons sur la base de $ a_ {n + 2} $. $a_{n+2} = a_{n+1} + a_{n}$ $a_{n+2} = (a_{n} + a_{n-1}) + a_{n}$ $a_{n+2} = a_{n} + 2a_{n-1} + a_{n-2}$ Après cela, lorsque le terme dont le coefficient est 2 est développé pour que le coefficient devienne 1. $a_{n+2} = a_{n} + a_{n-1} + 2a_{n-2}+ a_{n-3}$ $…$

À côté de la transition $a_{n+2} - a_{1} = \sum a_n $ Ce sera.