bonjour

Je désire un "compteur" sur les éléments (True) qui se suivent, par exemple :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1 1 0 1 1 0 1 0 1 1 1
a a 0 b b 0 0 0 c c c    # je dois trouver
 
1 0 1 1 0 1 0 1 1 1 1
0 0 a a 0 0 0 b b b b    # je dois trouver
 
 
1 0 1 1 0 1 0 1 1 0 1
0 0 a a 0 0 0 b b 0 0    # je dois trouver
 
0 1 1 0 1 0 1 1 0 1 0
0 a a 0 0 0 b b 0 0 0    # je dois trouver
 
0 1 1 0 1 0 0 1 1 1 0
0 a a 0 0 0 0 b b b 0    # je dois trouver
Ici, j'ai utilisé "abc" pour plus de clarté dans "l'énoncé", mais dans mon code test, j'ai utilisé un simple nombre.

Je pense qui je ne suis pas loin de trouver une solution, mais le code me pique déjà les yeux (donc pas envie d'ajouter des if...). Peut-être qu'il existe une solution pythonnesque ? j'ai regardé du coté de itertools, mais ne l'utilisant jamais, je ne pense pas que mon bonheur y soit.

A noter qu'il n'y a pas de notion de performance, max : 36 listes de 64 objets

Code de mon test
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
datas = [
    [1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1],
    [1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1],
    [1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1],
    [0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0],
    [0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0],
]
ok = [
    [1, 1, 0, 2, 2, 0, 0, 0, 3, 3, 3],
    [0, 0, 1, 1, 0, 0, 0, 2, 2, 2, 2],
    [0, 0, 1, 1, 0, 0, 0, 2, 2, 0, 0],
    [0, 1, 1, 0, 0, 0, 2, 2, 0, 0, 0],
    [0, 1, 1, 0, 0, 0, 0, 2, 2, 2, 0],
]
 
def horizontal(data: list) -> list:
    results = [0] * len(data)
    level = 0
    for i, value in enumerate(data):
        if not value:
            level += 1
        else:
            try:
                prev = data[i - 1]
            except IndexError:  # i==0
                prev = 0
            try:
                after = data[i + 1]
            except IndexError:  # dernier liste
                after = 0
                pass
            if prev or after:  # 2 de suite
                results[i] = level
            else:
                if level > 0:
                    level -= 1
 
    return results
 
 
if __name__ == "__main__":
    for y, line in enumerate(datas):
        results = horizontal(line)
        print("> ", line)
        print("  ", results, ok[y] == results)
        if ok[y] != results:
            print("# ", ok[y])
        print()
résultat actuel:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
>  [1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1]
   [0, 0, 0, 1, 1, 0, 0, 0, 2, 2, 2] False
#  [1, 1, 0, 2, 2, 0, 0, 0, 3, 3, 3]
 
>  [1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1]
   [0, 0, 1, 1, 0, 0, 0, 2, 2, 2, 2] True
 
>  [1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1]
   [0, 0, 1, 1, 0, 0, 0, 2, 2, 0, 0] True
 
>  [0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0]
   [0, 1, 1, 0, 0, 0, 2, 2, 0, 0, 0] True
 
>  [0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0]
   [0, 1, 1, 0, 0, 0, 0, 3, 3, 3, 0] False
#  [0, 1, 1, 0, 0, 0, 0, 2, 2, 2, 0]

EDIT:
trouvé une solution (que des True en sortie) et surtout plus de if else: En fait, sauvegarder les index puis faire un split (maison)

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def split_at_indices(lst, indices):
    results = []
    prev_index = 0
    for index in indices:
        results.append(lst[prev_index:index])
        prev_index = index + 1
    results.append(lst[prev_index:])
    return results
 
 
def horizontal(data: list) -> list:
    # sauve les index
    paired = list(zip(range(len(data)), data))
    indices = [x[0] for x in paired if x[1] == 0]
    # split et supprime les sequences trop courtes
    results = [x for x in split_at_indices(paired, indices) if len(x) > 1]
 
    # formate la sortie en fonction du besoin  )
    values = [0] * len(data)
    for key, sequence in enumerate(results, start=1):
        for value in sequence:
            values[value[0]] = key
    return values