PYTHON – поиск максимума из каждых 10 целых чисел в массиве

Таким образом, при отладке массива примеров мы обнаруживаем, что split возвращает двумерный список, подобный этому:

[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]]

И каждый раз, когда цикл for выполняется, он проходит по одному из этих списков по порядку. Сначала он проходит через первый внутренний список, затем второй и т. д. Поэтому каждый раз, когда цикл for переходит к следующему списку, мы просто добавляем 10. Поскольку в списке может быть более 2 списков, мы сохраняем число, которое нам нужно добавить. в переменной и добавляйте к ней 10 в каждом цикле:

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
split = [a[i:i+10] for i in xrange(0, len(a), 10)] 
counter = 0

for i in split:
    j = max(i) 
    k = i.index(max(i))
    print (j,k+counter)
    counter += 10

Вы можете протестировать его здесь

Небольшая модификация вашего текущего кода:

a = some array of integers

split = [a[i:i+10] for i in xrange(0, len(a), 10)] 

for index, i in enumerate(split):
    j = max(i) 
    k = i.index(max(i))
    print (j, k+10*index)

Вам нужно подсчитать количество элементов, которые появляются перед текущим окном. Это сделает работу:

a=list(range(5,35))
split = [a[i:i+10] for i in xrange(0, len(a), 10)] 

for ind,i in enumerate(split):
    j = max(i) 
    k = i.index(j)
    print (j,k+ind*10)

Это печатает

(14, 9)
(24, 19)
(34, 29)

Пакет toolz имеет файл partition_all, которая делит последовательность на кортежи одинакового размера, поэтому вы можете сделать что-то вроде этого.

import toolz
ns = list(range(25))
[max(sublist) for sublist in toolz.partition_all(10, ns)]

Это вернет [9, 19, 24].

Вам нужно будет выполнить цикл, чтобы просмотреть список, однако мы можем изменить ваш цикл split, чтобы сделать его более эффективным для того, что вы хотите.

a = some array of integers

split = [a[i:i+10] for i in xrange(0, len(a), 10)] 

for i in range(len(split)):
    #Now instead of being the list, i is the index, so we can use 10*i as a counter
    j = max(split[i]) 
    #j = max(i) 
    k = split[i].index(j) + 10*i #replaced max(i) with j since we already calculated it.
    #k = i.index(max(i))
    print (j,k)

Однако в будущем, пожалуйста, создайте новое имя для вашего списка split, так как split уже является функцией в python. Возможно, split_list или separated, или какое-то другое имя, не похожее на функцию split().

решение numpy для произвольного ввода:

import numpy as np

a = np.random.randint(1,21,40)  #40 random numbers from 1 to 20

b = a.reshape([4,10])  #shape into chunks 10 numbers long

i = b.argsort()[:,-1]  #take the index of the largest number (last number from argsort) 
                       #  from each chunk. (these don't take into account the reshape)

i += np.arange(0,40,10)  #add back in index offsets due to reshape

out = zip(i, a[i])  #zip together indices and values

Вы можете упростить это, перечислив только один раз и используя zip для разделения списка на группы:

n=10
for grp in zip(*[iter(enumerate(some_list))]*n):
    grp_max_ind, grp_mv=max(grp, key=lambda t: t[1])
    k=[t[1] for t in grp].index(grp_mv)
    print grp_mv, (grp_max_ind, k)

Используйте izip в Python 2, если вам нужен генератор (или используйте Python 3)

from itertools import izip 
for grp in izip(*[iter(enumerate(some_list))]*n):
    grp_max_ind, grp_mv=max(grp, key=lambda t: t[1])
    k=[t[1] for t in grp].index(grp_mv)
    print grp_mv, (grp_max_ind, k)

Zip обрежет последнюю группу, если ее длина не равна n

Пример использования numpy. Сначала сгенерируем некоторые данные, то есть целые числа от 1 до V и длиной (количество значений) L:

import numpy as np
V = 1000
L = 45 # method works with arrays not multiples of 10
a = np.random.randint(1, V, size=L)

Теперь решим задачу для подмассивов размера N:

import numpy as np
N = 10 # example "split" size
sa = np.array_split(a, range(N, len(a), N))
sind = [np.argpartition(i, -1)[-1] for i in sa]
ind = [np.ravel_multi_index(i, (len(sa), N)) for i in enumerate(sind)]
vals = np.asarray(a)[np.asarray(ind)]
split_imax = zip(vals, ind) # <-- output