如何创建一个滑动 window，它从较小数组的末尾开始，到 python 中较小数组的开头结束？

Question

I have 2 arrays:

[7, 6, 9, 8]
[1, 2, 3, 4, 5, 3, 2, 1]

I want to slide across them like so:

Iteration 1:

[7, 6, 9, |8|]
         [|1|, 2, 3, 4, 5, 3, 2, 1]

2:

[7, 6, |9, 8|]
      [|1, 2|, 3, 4, 5, 3, 2, 1]

3:

    [7,|6, 9, 8|]
      [|1, 2, 3|, 4, 5, 3, 2, 1]

4:

      [|7, 6, 9, 8|]
      [|1, 2, 3, 4|, 5, 3, 2, 1]

5:

         [|7, 6, 9, 8|]
      [1, |2, 3, 4, 5|, 3, 2, 1]

And it keeps going at the first array's length until...

Iteration 9:

                      [|7, 6, 9|, 8|]
       [1, 2, 3, 4, 5, |3, 2, 1|]

10:

                         [|7, 6|, 9, 8|]
       [1, 2, 3, 4, 5, 3, |2, 1|]

11:

                            [|7|, 6, 9, 8|]
       [1, 2, 3, 4, 5, 3, 2, |1|]

What have I already tried? A mess that just doesn't work, and I'm afraid sharing it will discourage many from even responding.

EDIT: Here's my non-working code for those who wanted to see it:

embedding_list_1 = [[1, 2, 3], [1, 3, 4], [1, 2, 4]]
embedding_list_2 = [[1, 2, 3], [1, 3, 4], [1, 2, 4], [1, 2, 4], [1, 2, 4], [3, 4, 5]]
region_range = 1
first_run = True
increment = True
embedding_list_2_start = 0

embedding_list_2_end = len(embedding_list_1)
while region_range >= 0:
  if first_run:
    print('Cutting embedding list 1 from:', len(embedding_list_1)-region_range, 'to', len(embedding_list_1))
    print(embedding_list_1[len(embedding_list_1)-region_range:])
    print('Cutting embedding list 2 from:', 0, 'to', region_range)
    embedding_list_2[:region_range]
    region_range +=1
    first_run = False
  else:
    

    chopped_off = embedding_list_1[len(embedding_list_1)-region_range:]
    print(chopped_off)

    embedding_list_2[embedding_list_2_start:region_range]
    if increment:
      region_range +=1

    
    if region_range == len(embedding_list_1):
      #break
      #use full list 
      
      print(len(embedding_list_1))
      embedding_list_2_start+=1
      embedding_list_2_end+=1
      print('Cutting embedding list 2 from', embedding_list_2_start, 'to', embedding_list_2_end)
      print(embedding_list_2[embedding_list_2_start:embedding_list_2_end])
      increment = False

      

      if embedding_list_2_end == len(embedding_list_2):
        #Stop incrementing end
        #Start negative shift for other embedding
        region_range-=1
        print('Cutting embedding list 1 from: 0', 'to', region_range)
        embedding_list_1[0:region_range]

        embedding_list_2_start+=1
        embedding_list_2_end+=1
        print('cuting embedding list 2 from:', embedding_list_2_start, embedding_list_2_end)
        embedding_list_2[:embedding_list_2_end]

Answer 1

Here's a quick, possibly quite dirty attempt.

The overlap looks like this in the first iteration:

Let's look at everything relative to list2 first. In the first iteration

# Calculate the offset between the two lists
offset = 1 - len(list1) # -3

l2_window_start = offset
l2_window_end = 0

# The slice for list2 starts at the larger of 0 and l2_window_start
l2_start = max(0, l2_window_start)
# The slice for list2 ends at the smaller of 7 and l2_window_end
l2_end = min(len(list2) - 1, l2_window_end)

# Add one to l2_end because slices don't contain the end index.
list2_slice = list2[l2_start:l2_end+1]

Now, looking at list1 using these numbers:

l1_window_start = -offset # starts off at 3

l1_start = max(0, l1_window_start)
# list1 slice needs to have as many elements as list2_slice
l1_end = l1_start + len(list2_slice)

list1_slice = list1[l1_start:l1_end]

As the iterations move forward, l2_window_start , l2_window_end and offset all increase by 1. l1_window_start decreases by 1.

Putting this in a loop:

list1 = [7, 6, 9, 8]
list2 = [1, 2, 3, 4, 5, 3, 2, 1]
offset = l2_window_start = 1 - len(list1) # -3
l2_window_end = 0
l1_window_start = -offset
l1_window_end = len(list1) - 1
for iternum in range(11):
    # The slice for list2 starts at the larger of 0 and l2_window_start
    l2_start = max(0, l2_window_start)
    # The slice for list2 ends at the smaller of 7 and l2_window_end
    l2_end = min(len(list2) - 1, l2_window_end)
    
    # Add one to l2_end because slices don't contain the end index.
    list2_slice = list2[l2_start:l2_end+1]

    l1_start = max(0, l1_window_start)
    l1_end = l1_start + len(list2_slice)
    
    list1_slice = list1[l1_start:l1_end]    

    print(iternum+1, list1_slice, list2_slice)
    l1_window_start -= 1;
    l2_window_start += 1; l2_window_end += 1; offset += 1

Which gives us the required output:

1 [8] [1]
2 [9, 8] [1, 2]
3 [6, 9, 8] [1, 2, 3]
4 [7, 6, 9, 8] [1, 2, 3, 4]
5 [7, 6, 9, 8] [2, 3, 4, 5]
6 [7, 6, 9, 8] [3, 4, 5, 3]
7 [7, 6, 9, 8] [4, 5, 3, 2]
8 [7, 6, 9, 8] [5, 3, 2, 1]
9 [7, 6, 9] [3, 2, 1]
10 [7, 6] [2, 1]
11 [7] [1]

---

Answer 2

My solution is very similar (maybe ultimately the same) as @pranav-hosangadi's answer. I produce a slightly different result as my answer produces tuples based on pairing up the windowed elements from each list.

As with @pranav-hosangadi's answer, we start with ranging over a range that encompasses the full slide. The tricky part (at least for me) was working out the right starts and ends.

a = [7, 6, 9, 8]
b = [1, 2, 3, 4, 5, 3, 2, 1]

a_len = len(a)
b_len = len(b)

for i in range(0, a_len + b_len -1):
  a_start = max(0, a_len -i -1)
  a_end = min(a_len, a_len + b_len - i)
  b_start = max(0, i + 1 - a_len)
  b_end = min(i + 1, b_len)
  result = [(a[x], b[y]) for (x, y) in zip(range(a_start, a_end), range(b_start, b_end))]
  print(result)

This produces the slightly different (wrong?) output:

[(8, 1)]
[(9, 1), (8, 2)]
[(6, 1), (9, 2), (8, 3)]
[(7, 1), (6, 2), (9, 3), (8, 4)]
[(7, 2), (6, 3), (9, 4), (8, 5)]
[(7, 3), (6, 4), (9, 5), (8, 3)]
[(7, 4), (6, 5), (9, 3), (8, 2)]
[(7, 5), (6, 3), (9, 2), (8, 1)]
[(7, 3), (6, 2), (9, 1)]
[(7, 2), (6, 1)]
[(7, 1)]

Answer 3

Here is a slightly different variation on using the zip function;

l1 = [7, 6, 9, 8]
l2 = [1, 2, 3, 4, 5, 3, 2, 1]

def slide(la, lb):
    lxa = []
    lxa = [x for x in range(len(la))]
    lxa.extend([None]* (len(lb) - 1))
    lxb = [None] * (len(la) -1)
    lxb.extend([x for x in range(len(lb))])
    lxcnt = 0
    rslt = []
    while lxcnt < len(lxa):
        tmp = []
        matchs = zip(lxa, lxb)
        for mtch in matchs:
            if mtch[0] != None and mtch[1] != None:
                tmp.append(mtch)
        if tmp:
            rslt.append(tmp)
        lxa.insert(0, None)
        lxa = lxa[:-1]
        lxcnt += 1
    return rslt

running slide(l1, l2) , yields:

[[(3, 0)], 
[(2, 0), (3, 1)], 
[(1, 0), (2, 1), (3, 2)], 
[(0, 0), (1, 1), (2, 2), (3, 3)], 
[(0, 1), (1, 2), (2, 3), (3, 4)], 
[(0, 2), (1, 3), (2, 4), (3, 5)], 
[(0, 3), (1, 4), (2, 5), (3, 6)], 
[(0, 4), (1, 5), (2, 6), (3, 7)], 
[(0, 5), (1, 6), (2, 7)], 
[(0, 6), (1, 7)], 
[(0, 7)]]