J'utilise beaucoup les opérations de tranche depuis que j'ai commencé à étudier python, donc j'aimerais le résumer ici pour ma propre confirmation.
Tout d'abord, à partir du tableau, en python, le tableau créé est automatiquement numéroté (appelé index), et le numéro du contenu créé à partir de 0 est attribué.
l = [5,3,1,2]
print(l.index(5))
print(l.index(3))
print(l.index(1))
print(l.index(2))
$ python atcoder.py
0
1
2
3
Il s'avère que 0123 est attribué afin de 5,3,1,2 dans le tableau comme ceci. En passant, .index () de l.index () est une fonction qui peut être utilisée pour des choses avec des index tels que des tableaux, et vous pouvez obtenir le numéro d'index de l'endroit spécifié.
Ensuite, utilisez cet index pour récupérer les valeurs du tableau.
l = [5,3,2,1]
print(l[0])
print(l[2])
$ python atcoder.py
5
2
Ajoutez [] au tableau comme ceci et spécifiez l'index que vous voulez y récupérer. Si vous définissez l [0], vous pouvez obtenir le 0ème 5ème.
Ensuite, prenez le contenu de plusieurs tableaux au lieu d'un.
l = [5,3,2,1]
print(l[0:2])
$ python atcoder.py
[5, 3]
Comme vous pouvez le voir lorsque vous souhaitez prendre plusieurs valeurs, utilisez [Index: Index]. Vous pouvez passer du nombre spécifié au début à la plage du nombre spécifié plus tard. Veuillez noter que si vous définissez [0: 2] avec l'instruction for, etc., vous obtiendrez la valeur un avant 2, c'est-à-dire, dans ce cas, la valeur de 0 à 1.
Vient ensuite la méthode du début à la fin, ou du début à la fin
l = [5,3,2,1]
print(l[1:])
$ python atcoder.py
[3, 2, 1]
l = [5,3,2,1]
print(l[:3])
$ python atcoder.py
[5, 3, 2]
Le premier récupère la valeur de l'index spécifié par [Index:] jusqu'à la fin. Ce dernier est jusqu'à l'indice spécifié depuis le début avec [: Index], et ce dernier est jusqu'à un avant comme expliqué précédemment.
Cela peut ne pas se produire dans la vie de tous les jours, mais où les nombres sont alignés côte à côte et où les divisez-vous pour réduire la différence de taille entre la gauche et la droite? L'opération de tranchage est pratique dans de tels cas.
l = [3,14,6,40,2,6,17,4,6,7,38,5,44,22,1,6,6,7]
for i in range(1,len(l)):
l_l = l[:i]
print(f"l_l{l_l}")
l_r = l[i:]
print(f"l_r{l_r}")
En augmentant la valeur d'un certain nombre jusqu'à un certain nombre et la valeur d'un certain nombre à partir d'un certain nombre un par un, il peut être divisé en droite et à gauche à toutes les positions. Si la plage est de 1 à 0, l_l dans la première boucle devient l [: 0], et un tableau vide est terminé. Il n'est pas nécessaire de comparer le ciel avec les autres, alors je l'ai fait.
l_l[3]
l_r[14, 6, 40, 2, 6, 17, 4, 6, 7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14]
l_r[6, 40, 2, 6, 17, 4, 6, 7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6]
l_r[40, 2, 6, 17, 4, 6, 7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40]
l_r[2, 6, 17, 4, 6, 7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2]
l_r[6, 17, 4, 6, 7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6]
l_r[17, 4, 6, 7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17]
l_r[4, 6, 7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4]
l_r[6, 7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6]
l_r[7, 38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6, 7]
l_r[38, 5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6, 7, 38]
l_r[5, 44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6, 7, 38, 5]
l_r[44, 22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6, 7, 38, 5, 44]
l_r[22, 1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6, 7, 38, 5, 44, 22]
l_r[1, 6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6, 7, 38, 5, 44, 22, 1]
l_r[6, 6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6, 7, 38, 5, 44, 22, 1, 6]
l_r[6, 7]
l_l[3, 14, 6, 40, 2, 6, 17, 4, 6, 7, 38, 5, 44, 22, 1, 6, 6]
l_r[7]
Je devrais donc prendre toutes les différences d'ici, ce n'est pas lié à cet article, mais je vais l'écrire pour le moment
l = [3,14,6,40,2,6,17,4,6,7,38,5,44,22,1,6,6,7]
min_g = 10000000
ans = 0
for i in range(len(l)):
l_l = l[:i]
l_r = l[i:]
if min_g > abs(sum(l_l)-sum(l_r)):
min_g = abs(sum(l_l)-sum(l_r))
ans = i
print(ans)
$ python atcoder.py
10
Il semble qu'il n'y ait aucune différence dans la méthode de division des numéros d'index jusqu'au 10e et à partir du 10e.
Il y a encore beaucoup de tranches et il est difficile de toutes les écrire, j'ai donc écrit celles que j'utilise beaucoup dans les bases.
Recommended Posts