How to rotate number at index[1] in a nested list python

Question

I am working on a problem that need me rotate the numbers at index[1] in a nested loop once toward the right. The nested loop looks like this [(1, 1), (2, 2), (3, 3), (4, 4), (1, 5)] and i want the nested loop to look like this [(1, 5), (2, 1), (3, 2), (4, 3), (1, 4)] (All the number at index[1] moved once to the right) I want to do this at a range of N times. I tried using deque from the module collections but it didn't do the thing i wanted. Here are my code.

from collections import deque
n = int(input())
a = [int(i) for i in input().split()]
s, f = map(int, input().split())
num = 0

sequence = [i for i in range(1, len(a) + 1)]
res = list(zip(a, sequence))
print(res)
for i in res:
    res1 = deque(i[1])
    res1.rotate(1)
    print(res1)

I got an error on line 11

   res1 = deque(i[1])
TypeError: 'int' object is not iterable

Your question is unclear. Show your and clarify your question — drum
– drum, Commented Aug 29, 2020 at 1:14
@superbrain i want to rotate the numbers at index[1] n times. But n could be any number — Andrew Qiu
– Andrew Qiu, Commented Aug 29, 2020 at 1:21

superb rain · Accepted Answer · 2020-08-29 01:42:14Z

4

Could separate them into firsts and seconds, shift the seconds, and recombine:

a, b = zip(*lst)
lst = [*zip(a, b[-1:] + b[:-1])]

or just

a, b = zip(*lst)
lst = [*zip(a, b[-1:] + b)]

Use -n to rotate n steps (if n can be negative or longer than the list, take it modulo the length of the list first).

edited Aug 29, 2020 at 1:42

answered Aug 29, 2020 at 1:21

superb rain

5,5512 gold badges14 silver badges25 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Iain Shelvington Over a year ago

list(zip(a, b[-1:] + b[:-1])) will do as the 2nd line, I think it's slightly more readable to use list(iterable) than it is to use [*iterable] as the syntax may confuse some devs that aren't used to it

superb rain Over a year ago

@IainShelvington I used to think so, but I got used to [*iterable]. Maybe people will get more used to it over time (except those people who still write set([4, 2]) instead of {4, 2}).

Marat · Accepted Answer · 2020-08-29 03:29:22Z

2

It could be a one-liner:

[(x[0], y[1]) for x, y in zip(l, l[-1:] + l)]

but Superb rain's answer is more explicit/pythonic

answered Aug 29, 2020 at 3:29

Marat

15.9k3 gold badges44 silver badges53 bronze badges

1 Comment

superb rain Over a year ago

Ha, I actually prefer yours. I think I just thought zip as soon as I saw those tuples, never even considering a list comp here.

Bharel · Accepted Answer · 2020-08-29 02:57:49Z

0

Just for the sake of it - Optimized solution:

from collections import deque
def rotate_second_indices(lst, n=1):
    assert n < len(lst)
    buffer = deque(lst[i][1] for i in range(-n,0))
    for index, (a, b) in enumerate(lst):
        lst[index] = (a, buffer.popleft())
        buffer.append(b)

Original answer

That code should do it:

lst = [(1, 1), (2, 2), (3, 3), (4, 4), (1, 5)]
new = lst[-1][1]
for index, (first, second) in enumerate(lst):
    lst[index] = (first, new)
    new = second

Another option:

lst = [(1, 1), (2, 2), (3, 3), (4, 4), (1, 5)]
first_lst, second_lst = zip(*lst)
second_lst = list(second_lst)
second_lst.insert(0, second_lst.pop())
lst = list(zip(first_lst, second_lst))

And another option:

first, second = zip(*lst)
second = deque(second)
second.rotate()
lst = list(zip(first, second))

edited Aug 29, 2020 at 2:57

answered Aug 29, 2020 at 1:15

Bharel

27.5k8 gold badges52 silver badges100 bronze badges

10 Comments

superb rain Over a year ago

You mean was it wrong? I think it was downvoted when you only had the first solution. And I think that one doesn't scale well to the desired larger rotations, maybe someone didn't like that. But I love the deque one, so have my upvote :-)

Bharel Over a year ago

@superbrain Thank you :-) I do think a buffer of rotations together with the first solution is more scalable tbh. I've upvoted your answer, but like my 2 other solutions, it causes copying of the data.

superb rain Over a year ago

Not sure what you mean with buffer of rotations. But presumably it requires a bigger code rewrite than passing n to rotate :-)

superb rain Over a year ago

Meh, that "highly memory-optimized" version takes O(n) extra space. I meant this, which only takes O(1) extra space.

superb rain Over a year ago

Only two passes, really. The two partial passes together make one complete pass. But yes, it's probably slower. Only memory-optimized.

|

superb rain · Accepted Answer · 2020-08-29 02:58:50Z

0

Rotate-by-n with O(1) extra space^[*] using the old triple-reverse:

a = [(1, 1), (2, 2), (3, 3), (4, 4), (1, 5)]
n = 2

def reverse(start, stop):
    i, j = start, stop - 1
    while i < j:
        a[i], a[j] = (a[i][0], a[j][1]), (a[j][0], a[i][1])
        i += 1
        j -= 1
k = -n % len(a)
reverse(0, k)
reverse(k, len(a))
reverse(0, len(a))

print(a)

Output:

[(1, 4), (2, 5), (3, 1), (4, 2), (1, 3)]

^[*]: Except when there are other references to the tuples, in which case they can't go to the free list and become reused.

answered Aug 29, 2020 at 2:58

superb rain

5,5512 gold badges14 silver badges25 bronze badges

Comments

Nicolas Gervais · Accepted Answer · 2020-08-29 14:06:43Z

0

You had a good start with collections.deque:

from collections import deque

f = [(1, 1), (2, 2), (3, 3), (4, 4), (1, 5)]

d = deque(map(lambda x, y: y, *zip(*f)))

d.rotate(1)

list(zip(map(lambda x, y: x, *zip(*f)), d))

[(1, 5), (2, 1), (3, 2), (4, 3), (1, 4)]

answered Aug 29, 2020 at 14:06

Nicolas Gervais

36.9k23 gold badges123 silver badges160 bronze badges

Collectives™ on Stack Overflow

How to rotate number at index[1] in a nested list python

5 Answers 5

2 Comments

1 Comment

10 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

2 Comments

1 Comment

10 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related