Comment obtenir chaque ligne en Python ?

Question

J'ai besoin de faire ça :

"""
Program a function

    def increasing (m)

qui sera capable, pour toute matrice m d'entiers positifs, de vérifier si les sommes des lignes de ce tableau sont croissantes.

examples
1 3 2 5        The sums of the rows        2 8 4 1        The sums of the rows
7 9 4 1        are 11, 21 and 23.          6 2 8 5        are 15, 21 and 15.
3 5 6 9        --> increasing              8 4 2 1        --> not increasing
"""

Donc, je veux utiliser sum() ce qui est parfaitement faisable, je suppose.

J'ai commencé comme ça :

def increasing (m):
    for row in m:
        row[1]

Mais je sais que row[1] va juste sortir les nombres dans indice 1 de chaque rangée. Ce que j'ai en tête est le suivant :

def increasing (m):
    for row in m:
        if sum(row)[first_row] > sum(row)[second_row]:
           return False

Mais ce n'est qu'un découpage, et je ne sais pas comment compter les rangs pour pouvoir les comparer.

Je ne veux pas utiliser de module ou quoi que ce soit, juste du simple Python. Quelqu'un peut-il m'indiquer la bonne direction ? J'ai juste besoin que ce soit aussi simple que possible.

Exemple de format d'entrée :

increasing_l = [
    [1, 3, 2, 5],
    [7, 9, 4, 1],
    [3, 5, 6, 9]
]

not_increasing_l = [
    [2, 8, 4, 1],
    [6, 2, 8, 5],
    [8, 4, 2, 1]
]

test1 = increasing(increasing_l)
test2 = increasing(not_increasing_l)

print "should be True: %s" % test1
print "should be False: %s" % test2

Answer 1

Vous pouvez procéder comme suit :

def increasing(m):
    return all(sum(r1) < sum(r2) for r1, r2 in zip(m, m[1:]))

Cela utilise zip pour jumeler des rangées adjacentes et all pour effectuer efficacement la comparaison de la somme par paire.

Sans zip :

return all(sum(m[i-1]) < sum(m[i]) for i in range(1, len(m)))

Answer 2

Supposons que vous ayez une fonction "sum" qui renvoie la somme d'une ligne donnée. Vous pouvez utiliser une variable temporaire pour conserver la somme de votre ligne actuelle et l'utiliser pour la vérification. Par exemple :

def increasing (m):
    prevRow = 0
    currentRow = 0
    for row in m:
        currentRow = sum(row)
        if (currentRow <= prevRow):
           return False
        prevRow= currentRow
    else:
        return True

Answer 3

Il suffit de stocker la dernière somme pour obtenir une réponse :

def increasing(m):
    last_sum = -float('inf')
    for row_sum in map(sum, m):
        if row_sum < last_sum:
            return False
        last_sum = row_sum

    return True

Answer 4

Vous pouvez d'abord créer un list de la sums de la rows et vérifiez ensuite si cette list est en augmentation.

def increasing(m):
    sums = [sum(r) for r in m]
    return all(sums[i] < sums[i+1] for i in range(len(m)-1))

et nous pouvons tester cela avec :

m1  = [[1, 3, 2, 5],
       [7, 9, 4, 1],
       [3, 5, 6, 9]]

m2  = [[2, 8, 4, 1],
       [6, 2, 8, 5],
       [8, 4, 2, 1]]

qui produit les résultats corrects :

>>> increasing(m1)
True
>>> increasing(m2)
False

Answer 5

Juste simplement faire

row[0]+row[1]+row[2]+row[3]

pour le processus de sommation et le problème de ne pas connaître les numéros de ligne est géré par l'itération sur les lignes, ce qui ne posera aucun problème.