We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
Loading...
  1. Practice
  2. Tutorials
  3. Cracking the Coding Interview
  4. Arrays: Left Rotation
  5. Discussions

Arrays: Left Rotation

  • kevinmathis08 + 10 comments

    Yeah index slicing FTW, here was my 1-liner in definition, lol:

    def array_left_rotation(a, n, k):
    return a[k:]+a[:k]

n, k = map(int, input().strip().split(' '))
a = list(map(int, input().strip().split(' ')))
answer = array_left_rotation(a, n, k);
print(*answer, sep=' ')
    • Lord_krishna + 1 comment

      is that scala?

      • domar + 0 comments

        It's Python 3

    • aniket_vartak + 1 comment

      you dont need to pass n to your function, right..

      • michael_bubb + 2 comments

        I agree - I ended up not using 'n' (Python):

        def left_shift(n,k,a):
   for _ in range(k):
      a.append(a.pop(0))
   print(*a)
        • unitraxx + 1 comment

          Obviously this solves the problem, but is a terrible solution. Pop is an O(N) operation. So your solution becomes O(K*N). This should be done in O(N) total time complexity. You do have the space requirement of O(1) correct. All the standard solutions have a O(N) space complexity.

          • asfaltboy + 1 comment

            True. However, it becomes an elegant solution if we use collections.dequeue instead of list. Double ended queues have a popleft method, which is an O(1) operation:

            def array_left_rotation(a, n, k):
    for _ in range(k):
        a.append(a.popleft())
    return a

            More info: https://wiki.python.org/moin/TimeComplexity#collections.deque https://docs.python.org/3/library/collections.html#collections.deque

            • AffineStructure + 1 comment

              They have rotate built into the deque

              def array_left_rotation(a, n, k):
    a = deque(a)
    for i in range(k):
        a.rotate(-1)
    return a
              • josegabriel_st + 0 comments

                You have O(n) in:

                a = deque(a)

                In order to avoid this, you should use a deque from the beginning like:

                from collections import deque

def array_left_rotation(a, n, k):
    a.rotate(-k)

n, k = map(int, input().strip().split(' '))
a = deque(map(int, input().strip().split(' ')))
array_left_rotation(a, n, k);
print(*a, sep=' ')

                And array_left_rotation only takes O(k) instead of O(n).

                Note that a is pased by reference, so there is no need to return anything, but this could be an issue for some user cases, for this particular problem, it works.

        • navi_srm + 0 comments

          def array_left_rotation(a, n, k): return (a[k:] + a[:k])

    • ansimionescu + 1 comment

      k -> k%n

      • frostje + 0 comments

        k%n handles any range of shifts, but the problem specifies n < k so you can just use k in this case

    • loks30 + 1 comment

      This logic fails when k>n.

      • madhuvasu7 + 0 comments

        for that, do:

        k = k%n
    • chrislucas + 0 comments

      Nice, only one line was added

    • marwinko19 + 0 comments

      Perfection. Short, simple, & clean.

    • ahmettortumlu25 + 0 comments

      hmm nice....

    • aliie62 + 0 comments

      It's so smart! well done:)

    • toaa_kama2354 + 0 comments

      Can you please explain how (a[k:]+a[:k]) is working?

    • jae_duk_seo + 0 comments

      Damn this is super impressive.