Соответствие итераций в списках, имеющих значительные трудности

Question

Для личного проекта у меня есть три списка. Один из них содержит набор массивов (l2), размер которых всегда определяется настройкой l2_size и всегда содержит случайные члены l1. Следующий массив, l3, с другой стороны, всегда будет набором из 0 количества len (l1).

Это означает, что ...

l1 = [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5] 
l2 = [[3, 4, 5, 2, 4],[3, 5, 1, 2, 4], [4, 3, 2, 1, 5]] 
l3 = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] 

Мне нужно выполнить поиск, например, что

1. Начиная с l2 [0], если указатель l2 [0] попадает l2 [0], выполните поиск через l1, чтобы найти l1 [i] == первое значение l2 [0].

2. Как только первое значение l2 [0] использует l3 для назначения его соответствующего значения.

3. Поскольку размер массивов в l2 [0] составляет 5 членов, мы собираемся присвоить соответствующее значение от 1 до l3 максимум пять раз. Как только мы ударили по этой цели, мы перейдем к следующему набору l2 [1].

4. Как только мы закончим с l2 [0] (так далее, чтобы l2 [1]), нам нужно назначить следующее соответствующее значение, поэтому 2, не перегружая значения в l3.

Иллюстрация ...

Представьте себе это бейсбол скоринг карты ... У меня есть l1 бейсбольные карточки в моей палубе. Композиции бейсбольных карточек, которые я хочу в моих руках, содержатся в l2. Эти карты выиграют мне игру! В этом случае l2 = [1,2,3,4,5]. Я массивный читер и должен найти все l2 в l1 (карты для рук). Поиск l2 в l1 Я отмечаю, где они используют l3. Я также использую l3, чтобы указать, с какой стороны их помещать.

Для правильного решения мы должны однозначно сопоставлять значения в l2 так, чтобы они были однозначно идентифицированы как значения в l1 с использованием l3. Это будет означать ...

l1 = [1,2,3,4,5,1,2,3,4,5] 
l2 = [[1,2,3,4,5],[1,2,3,4,5]] 
l3 = [1,1,1,1,1,2,2,2,2,2] 

Было бы действительно. Но ...

l1 = [1,2,3,4,5,1,2,3,4,5] 
l2 = [[1,2,3,4,5],[1,2,3,4,5]] 
l3 = [1,2,1,1,1,2,2,1,2,2] 

Было бы недопустимо, так как нет рук в l2, содержащий [2,1,2,4,5] в любом порядке.

Пример

С l2 [0] мы будем перебирать l1 снова и снова и забрать все объекты в l2 [0] и подписать их в l3. Это должно выглядеть так (вручную) ...

l1 = [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5] 
l2 = [[3, 4, 5, 2, 4],[3, 5, 1, 2, 4], [4, 3, 2, 1, 5]] 
l3 = [0,0,1,1,1,0,1,0,1,0,0,0,0,0,0]   

Значение 1 присвоено в l3, поскольку это первые экземпляры соответствующих значений мы сталкиваемся. Теперь мы закончили с l2 [0], потому что мы нашли все его элементы в l1. Следующее задание - l2 [1] ...

l1 = [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5] 
l2 = [[3, 4, 5, 2, 4],[3, 5, 1, 2, 4], [4, 3, 2, 1, 5]] 
l3 = [2,2,1,1,1,0,1,0,1,0,0,0,2,2,2]   

Это то, что я приготовил, но безрезультатно ...

assignvar = 1 
pos = 0 
for x in l2: 
    for y in x: 
     for z in l1: 
      while userpos < len(l1): 
       if y == z: 
        l1[pos] = assignvar 
        while l2_size == pos: 
         assignvar += 1 
         l2_size = l2_size+l2_size #stops pos going out of range, changes assignvar to 2 (so appending the next set of l3 iterables to 2 .etc) 
       userpos = userpos+1 

Действительно совершенно смущен, как подойти к этой проблеме в моем коде. Я чувствую, что у меня есть правильная идея, использующая три для петель, но я уже некоторое время ударяю это с помощью своего гаечного ключа и полностью сгорел.

Реальный мир входных наборов данных ...

l1 = [5005.0, 5002.5, 5003.0, 5003.0, 5003.5, 5002.5, 5003.5, 5004.0, 5004.5, 5004.0, 5002.5, 5005.0, 5004.5, 5004.0, 5005.0, 5002.5, 5003.5, 5004.0, 5002.5, 5002.5, 5004.0, 5004.0, 5003.5, 5001.5, 5001.5, 5005.0, 5003.0, 5005.0, 5003.5, 5000.5, 5002.5, 5003.5, 5005.0] 

l2 = [[5002.5, 5004.0], [5002.5, 5004.5], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5004.5], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5005.0], [5003.0, 5003.5], [5003.0, 5003.5], [5003.0, 5004.0], [5003.0, 5004.5], [5003.0, 5004.0], [5003.0, 5005.0], [5003.0, 5004.5], [5003.0, 5004.0], [5003.0, 5005.0], [5003.0, 5003.5], [5003.0, 5004.0], [5003.0, 5004.0], [5003.0, 5004.0], [5003.0, 5003.5], [5003.0, 5005.0], [5003.0, 5005.0], [5003.0, 5003.5], [5003.0, 5003.5], [5003.0, 5005.0], [5003.0, 5003.5], [5003.0, 5003.5], [5003.0, 5004.0], [5003.0, 5004.5], [5003.0, 5004.0], [5003.0, 5005.0], [5003.0, 5004.5], [5003.0, 5004.0], [5003.0, 5005.0], [5003.0, 5003.5], [5003.0, 5004.0], [5003.0, 5004.0], [5003.0, 5004.0], [5003.0, 5003.5], [5003.0, 5005.0], [5003.0, 5005.0], [5003.0, 5003.5], [5003.0, 5003.5], [5003.0, 5005.0], [5002.5, 5004.0], [5002.5, 5004.5], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5004.5], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5004.5], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5004.0], [5002.5, 5004.0], [5002.5, 5005.0], [5002.5, 5005.0], [5002.5, 5005.0], [5001.5, 5005.0], [5001.5, 5005.0], [5001.5, 5005.0], [5001.5, 5005.0], [5001.5, 5005.0], [5001.5, 5005.0], [5003.0, 5005.0], [5003.0, 5003.5], [5003.0, 5003.5], [5003.0, 5005.0], [5002.5, 5005.0]] 

l3=[] 
for i in range(len(l1)): 
    l3.append(int(0)) 

Answer 1

я упростил решение путем создания двух массивов дополнительных массивы называют «конфигурационное пространство», которое назначено логическим значение TRUE (представленное целым числом 1) в зависимости от числа (карты) были отнесены к руке или член подмножества (руки) уже назначен на карту.

Это решение совершает одно прохождение через l2, затем совершает переход через l1 и назначает карту рукой в ​​l3, только если обе руки и карта не назначены (как указано 0 в каждом массиве в конфигурационном пространстве).

l1 = [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5] #Total number of players 
l2 = [[3, 4, 5, 2, 4],[3, 5, 1, 2, 4], [4, 3, 2, 1, 5]] #Possible teams 
l3 = [] #Assigned teams 
for i in range(len(l1)): 
    l3.append(int(0)) 
############################################################################################################################################################## 
#Configuration space. Responsible for indicating whether (a) a player from l1 has been assigned to a team or (b) a team has already been assigned to a player# 
############################################################################################################################################################## 

playerbase_configurationspace = [] 
matchmadeteams_configurationspace = [] #detects if value in l2 has been assigned (if going over a number which has been given value 1 but we need to give it value 2) 

for i in range(len(l1)): 
    playerbase_configurationspace.append(int(0)) 
for x in l2: 
    for y in x: 
     matchmadeteams_configurationspace.append(int(0)) 


teamsize = len(l2[0]) 
teamcount = len(l2[0]) 
assignteam = 1 #Base no. of teams to be assigned 


################################ 
#Flatten list of lists########## 
################################ 

matchmadeteams_processed = [] 
for x in l2: 
    for y in x: 
     matchmadeteams_processed.append(y) 


#################################################################################################################################### 
#Teammate handler: makes lookups into the configuration space to help determine whether either a player has been assigned to a team# 
#################################################################################################################################### 

def teammate_handler(isnotfreeplayer,isnotfreeslot, assignteam): 

    if playerbase_configurationspace[isnotfreeplayer] == 0 and matchmadeteams_configurationspace[isnotfreeslot] == 0: 
     playerbase_configurationspace[isnotfreeplayer] = 1 
     matchmadeteams_configurationspace[isnotfreeslot] = 1          
     return int(1), assignteam #Outcome 1, safe to add player to empty slot, assign == value to be assigned 

    #else either, player is set team, teammate of team is set team (or both):: do nothing 
    elif playerbase_configurationspace[isnotfreeplayer] == 1 and matchmadeteams_configurationspace[isnotfreeslot] == 0: 
     return int(2) #Outcome 2, continue the for loop iterating through players since the player is not free but the slot is free 
    elif playerbase_configurationspace[isnotfreeplayer] == 0 and matchmadeteams_configurationspace[isnotfreeslot] == 1: 
     return int(3) #Outcome 3, break the for loop iterating through slots and players since the slot is not free 
    elif playerbase_configurationspace[isnotfreeplayer] == 1 and matchmadeteams_configurationspace[isnotfreeslot] == 1: 
     return int(4) 
    return int(5) #Unexpected error (catch all) 

############################### 

for teammatepos in enumerate(matchmadeteams_processed): 
    print(teamcount) 
    if teamcount == 0: 
     assignteam += 1 
     teamcount = teamsize 
    for playerpos in enumerate(l1): 
     if playerpos[1] == teammatepos[1]: 
      print("Match, using player"+str(playerpos)+" teammate"+str(teammatepos)) 
      print() 
      print ("Teammate "+str(teammatepos), matchmadeteams_processed) 
      print ("Player "+str(playerpos), l1) 
      print ("") 
      if teammate_handler(playerpos[0], teammatepos[0], assignteam) == (1, assignteam): 
       l3[playerpos[0]] = assignteam 
       print ("I have assigned teams to this player") 
      else: 
       continue 
     else: 
      continue 
    teamcount -= 1 
print(l3) 

Answer 2

прибудете Подсписок первый, а затем с помощью элемента Подсписок получить индекс в l1-х годов. увеличить 1 для l3 элемента на основе индекса L1 в

l1 = [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5] 
l2 = [[3, 4, 5, 2, 4],[3, 5, 1, 2, 4], [4, 3, 2, 1, 5]] 
l3 = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] 

def combinList(lst): 
    ''' put list of list together based on index 
     for example: 
     a = [1,3,5,7] 
     b = [2,4,6,8] 
     combined list should be [1,2,3,4,5,6,7,8] ''' 
    step = len(lst) 
    res= [None]*len( reduce(lambda x,y:x+y, lst)) 
    for i,item in enumerate(lst): 
     res[i::step] = sorted(item) 
    return res 


for value,line in enumerate(l2): 
    counter = 0 
    record = {} 
    # count how many time this element appeared 
    for i in line: 
     record[ i -1 ] = record.get(i - 1,0) + 1 
    newList = combinList([ [ i for i,j in enumerate(l1) if item == j] for item in line ]) 
    for idx in newList: 
     # if this element of l3 hasn't been change and there is at least one associated element in l2,put the value to l3 and reduce the number of l2 
     if not l3[idx] and record.get(idx%5,0): 
      l3[idx] = value + 1 
      counter+=1 
      record[idx%5] = record[idx%5] -1 
     if counter >=5: 
      break 
    print l3 
print l3 

выход:

#first iteration 
[0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] 
#second iteration 
[2, 1, 1, 1, 1, 0, 2, 2, 1, 2, 0, 0, 0, 2, 0] 
#third iteration 
[2, 1, 1, 1, 1, 3, 2, 2, 1, 2, 0, 3, 3, 2, 3] 
#final iteration 
[2, 1, 1, 1, 1, 3, 2, 2, 1, 2, 0, 3, 3, 2, 3] 

Answer 3

Еще немного туманными на спецификации, но попробовать это - он работает для простого случая l1 = [1,2,3,4,5,1,2,3,4,5] и l2 = [[1,2,3,4,5],[1,2,3,4,5]].

used_indices = set() 

def get_next_index(card, l1 = l1, used_indices = used_indices): 
    try: 
     # find the next index that has not been used 
     index = l1.index(card) 
     while index in used_indices: 
      # if the index has already been used, find the next one 
      index = l1.index(card, index + 1) 
    except ValueError as e: 
     # this card cannot be found 
     print('hand:{}, card:{} not found'.format(hand_no, card)) 
     index = None 
    return index 


for hand_no, hand in enumerate(l2, 1): 
    for card in hand: 
     index = get_next_index(card) 
     if index: 
      l3[index] = hand_no 
      used_indices.add(index)