Shift list elements to left by 3

Shift list elements to left by   3.

Shift list elements to left by 3 is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task
      shift  = [1,2,3,4,5,6,7,8,9]
      result = [4, 5, 6, 7, 8, 9, 1, 2, 3]



11l

Translation of: Python
F rotate(l, n)
   V k = (l.len + n) % l.len
   R l[k ..] [+] l[0 .< k]

V l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l‘  =>  ’rotate(l, 3))
Output:
[1, 2, 3, 4, 5, 6, 7, 8, 9]  =>  [4, 5, 6, 7, 8, 9, 1, 2, 3]

Action!

PROC PrintArray(INT ARRAY a INT size)
  INT i

  Put('[)
  FOR i=0 TO size-1
  DO
    IF i>0 THEN Put(' ) FI
    PrintI(a(i))
  OD
  Put(']) PutE()
RETURN

PROC ShiftLeft(INT ARRAY a INT size)
  INT i,j,tmp

  tmp=a(0)
  FOR i=0 TO size-2
  DO
    a(i)=a(i+1)
  OD
  a(size-1)=tmp
RETURN

PROC ShiftLeftNTimes(INT ARRAY a INT size,times)
  INT i

  FOR i=1 TO times
  DO
    ShiftLeft(a,size)
  OD
RETURN

PROC Test(INT ARRAY a INT size,offset)
  PrintArray(a,size)
  ShiftLeftNTimes(a,size,3)
  PrintArray(a,size)
RETURN

PROC Main()
  INT ARRAY a=[1 2 3 4 5 6 7 8 9]

  Test(a,9,-3)
RETURN
Output:

Screenshot from Atari 8-bit computer

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

Ada

Using slices and array concatenation.

with Ada.Text_Io;

procedure Shift_Left is

   Shift_Count : constant := 3;

   type List_Type is array (Positive range <>) of Integer;

   procedure Put_List (List : List_Type) is
      use Ada.Text_Io;
   begin
      for V of List loop
         Put (V'Image); Put ("  ");
      end loop;
      New_Line;
   end Put_List;

   Shift : List_Type := (1, 2, 3, 4, 5, 6, 7, 8, 9);
begin
   Put_List (Shift);

   Shift :=
     Shift (Shift'First + Shift_Count .. Shift'Last) &
       Shift (Shift'First .. Shift_Count);

   Put_List (Shift);
end Shift_Left;
Output:
 1   2   3   4   5   6   7   8   9
 4   5   6   7   8   9   1   2   3

ALGOL 68

BEGIN
    # shifts in place the elements of a left by n                          #
    PRIO <<:= = 1;
    OP   <<:= = ( REF[]INT a, INT n )REF[]INT:
         BEGIN
            INT    a length = ( UPB a - LWB a ) + 1;
            IF n < a length AND n > 0 THEN
                # the amount to shift is less than the length of the array #
                [ 1 : a length ]INT shifted;
                shifted[ 1                    : a length - n ] := a[ n + 1 :   @ 1 ];
                shifted[ ( a length + 1 ) - n :              ] := a[ 1     : n @ 1 ];
                a[ @ 1 ] := shifted
            FI;
            a
         END # <<:= # ;
    # prints the elements of v                                             #
    OP   PRINT = ( []INT v )VOID:
         BEGIN
            print( ( "[" ) );
            IF LWB v <= UPB v THEN
                print( ( whole( v[ LWB v ], 0 ) ) );
                FOR i FROM LWB v + 1 TO UPB v DO
                    print( ( "," , whole( v[ i ], 0 ) ) )
                OD
            FI;
            print( ( "]" ) )
         END # PRINT # ;            
    [ 1 : 9 ]INT v := ( 1, 2, 3, 4, 5, 6, 7, 8, 9 );
    PRINT v;
    print( ( " -> " ) );
    v <<:= 3;
    PRINT v;
    print( ( newline ) )
END
Output:
[1,2,3,4,5,6,7,8,9] -> [4,5,6,7,8,9,1,2,3]

ALGOL W

Translation of: ALGOL 68
begin
    % increments a and returns the new value %
    integer procedure inc ( integer value result a ) ; begin a := a + 1; a end;
    % shifts in place the elements of a left by n, a must have bounds lb::ub  %
    procedure  rotateLeft ( integer array a ( * ); integer value lb, ub, n ) ;
        if n < ( ub - lb ) and n > 0 then begin
            % the amount to shift is less than the length of the array %
            integer array shifted ( 1 :: n );
            integer aPos;
            for i := 0 until n - 1 do shifted( i ) := a( lb + i );
            for i := lb until ub - n do a( i ) := a( i + n );
            aPos := ub - n;
            for i := 0 until n - 1 do a( inc( aPos ) ) := shifted( i );
        end rotateLeft ;
    % prints the elements of v from lb to ub %
    procedure printArray ( integer array v ( * ); integer value lb, ub ) ;
    begin
        writeon( s_w := 0, "[" );
        if lb <= ub then begin
            writeon( i_w := 1, s_w := 0, v( lb ) );
            for i := lb + 1 until ub do writeon( i_w := 1, s_w := 0, "," , v( i ) )
        end;
        writeon( s_w := 0, "]" )
    end printArray ;
    begin
        integer array v ( 1 :: 9 );
        for i := 1 until 9 do v( i ) := i; 
        printArray( v, 1, 9 );
        writeon( " -> " );
        rotateLeft( v, 1, 9, 3 );
        printArray( v, 1, 9 );
        write()
    end
end.
Output:
[1,2,3,4,5,6,7,8,9] -> [4,5,6,7,8,9,1,2,3]

AppleScript

Functional

Prefix appended

------------- SHIFT LIST ELEMENTS TO LEFT BY 3 -----------

-- rotated :: Int -> [a] -> [a]
on rotated(n, xs)
    if 0  n then
        set m to |mod|(n, length of xs)
        
        (items (1 + m) thru -1 of xs) & ¬
            (items 1 thru m of xs)
    else
        xs
    end if
end rotated


--------------------------- TEST -------------------------
on run
    set xs to {1, 2, 3, 4, 5, 6, 7, 8, 9}
    
    unlines({"     Input list: " & showList(xs), ¬
        " Rotated 3 left: " & showList(rotated(3, xs)), ¬
        "Rotated 3 right: " & showList(rotated(-3, xs))})
end run


------------------------- GENERIC ------------------------

-- mod :: Int -> Int -> Int
on |mod|(n, d)
    -- The built-in infix `mod` inherits the sign of the 
    -- *dividend* for non zero results. 
    -- (i.e. the 'rem' pattern in some languages).
    --
    -- This version inherits the sign of the *divisor*.
    -- (A more typical 'mod' pattern, and useful,
    -- for example, with biredirectional list rotations).
    if signum(n) = signum(-d) then
        (n mod d) + d
    else
        (n mod d)
    end if
end |mod|


-- signum :: Num -> Num
on signum(x)
    if x < 0 then
        -1
    else if x = 0 then
        0
    else
        1
    end if
end signum


------------------------ FORMATTING ----------------------

-- intercalate :: String -> [String] -> String
on intercalate(delim, xs)
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, delim}
    set s to xs as text
    set my text item delimiters to dlm
    s
end intercalate


-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    -- The list obtained by applying f
    -- to each element of xs.
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map


-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
    -- 2nd class handler function lifted into 1st class script wrapper. 
    if script is class of f then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn


-- showList :: [a] -> String
on showList(xs)
    "{" & intercalate(", ", map(my str, xs)) & "}"
end showList


-- str :: a -> String
on str(x)
    x as string
end str


-- unlines :: [String] -> String
on unlines(xs)
    -- A single string formed by the intercalation
    -- of a list of strings with the newline character.
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, linefeed}
    set s to xs as text
    set my text item delimiters to dlm
    s
end unlines
Output:
     Input list: {1, 2, 3, 4, 5, 6, 7, 8, 9}
 Rotated 3 left: {4, 5, 6, 7, 8, 9, 1, 2, 3}
Rotated 3 right: {7, 8, 9, 1, 2, 3, 4, 5, 6}


Cycle sampled

Another approach: drawing from an infinite list of cycles:

------------- SHIFT LIST ELEMENTS TO LEFT BY 3 -----------

-- rotated :: Int -> [a] -> [a]
on rotated(n, xs)
    set m to length of xs
    
    take(m, drop(|mod|(n, m), cycle(xs)))
end rotated


--------------------------- TEST -------------------------
on run
    set xs to {1, 2, 3, 4, 5, 6, 7, 8, 9}
    
    unlines({"      Input list: " & showList(xs), "", ¬
        " Rotated  3 left: " & showList(rotated(3, xs)), ¬
        "                  " & showList(rotated(30, xs)), ¬
        " Rotated 3 right: " & showList(rotated(-3, xs)), ¬
        "                  " & showList(rotated(-30, xs))})
end run


------------------------- GENERIC ------------------------

-- cycle :: [a] -> Generator [a]
on cycle(xs)
    script
        property lng : 1 + (length of xs)
        property i : missing value
        on |λ|()
            if missing value is i then
                set i to 1
            else
                set nxt to (1 + i) mod lng
                if 0 = ((1 + i) mod lng) then
                    set i to 1
                else
                    set i to nxt
                end if
            end if
            return item i of xs
        end |λ|
    end script
end cycle


-- drop :: Int -> [a] -> [a]
-- drop :: Int -> String -> String
on drop(n, xs)
    set c to class of xs
    if script is not c then
        if string is not c then
            if n < length of xs then
                items (1 + n) thru -1 of xs
            else
                {}
            end if
        else
            if n < length of xs then
                text (1 + n) thru -1 of xs
            else
                ""
            end if
        end if
    else
        take(n, xs) -- consumed
        return xs
    end if
end drop


-- mod :: Int -> Int -> Int
on |mod|(n, d)
    -- The built-in infix `mod` inherits the sign of the 
    -- *dividend* for non zero results. 
    -- (i.e. the 'rem' pattern in some languages).
    --
    -- This version inherits the sign of the *divisor*.
    -- (A more typical 'mod' pattern, and useful,
    -- for example, with biredirectional list rotations).
    if signum(n) = signum(-d) then
        (n mod d) + d
    else
        (n mod d)
    end if
end |mod|


-- signum :: Num -> Num
on signum(x)
    if x < 0 then
        -1
    else if x = 0 then
        0
    else
        1
    end if
end signum


-- take :: Int -> [a] -> [a]
-- take :: Int -> String -> String
on take(n, xs)
    set c to class of xs
    if list is c then
        set lng to length of xs
        if 0 < n and 0 < lng then
            items 1 thru min(n, lng) of xs
        else
            {}
        end if
    else if string is c then
        if 0 < n then
            text 1 thru min(n, length of xs) of xs
        else
            ""
        end if
    else if script is c then
        set ys to {}
        repeat with i from 1 to n
            set v to |λ|() of xs
            if missing value is v then
                return ys
            else
                set end of ys to v
            end if
        end repeat
        return ys
    else
        missing value
    end if
end take


------------------------ FORMATTING ----------------------

-- intercalate :: String -> [String] -> String
on intercalate(delim, xs)
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, delim}
    set s to xs as text
    set my text item delimiters to dlm
    s
end intercalate


-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    -- The list obtained by applying f
    -- to each element of xs.
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map


-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
    -- 2nd class handler function lifted into 1st class script wrapper. 
    if script is class of f then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn


-- showList :: [a] -> String
on showList(xs)
    "{" & intercalate(", ", map(my str, xs)) & "}"
end showList


-- str :: a -> String
on str(x)
    x as string
end str


-- unlines :: [String] -> String
on unlines(xs)
    -- A single string formed by the intercalation
    -- of a list of strings with the newline character.
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, linefeed}
    set s to xs as text
    set my text item delimiters to dlm
    s
end unlines
Output:
      Input list: {1, 2, 3, 4, 5, 6, 7, 8, 9}

 Rotated  3 left: {4, 5, 6, 7, 8, 9, 1, 2, 3}
                  {4, 5, 6, 7, 8, 9, 1, 2, 3}
 Rotated 3 right: {7, 8, 9, 1, 2, 3, 4, 5, 6}
                  {7, 8, 9, 1, 2, 3, 4, 5, 6}

Two in-place alternatives

Fewest moves:

(* List range rotation, in-place with temporary external storage. Negative 'amount' = left rotation, positive = right.
    Method:
        Adjust the specified amount to get a positive, < list length, left-rotation figure.
        Store the range's leftmost 'amount' items.
        Move the range's other items 'amount' places to the left.
        Move the stored items into the range's rightmost slots.
*)
on rotate(theList, l, r, amount)
    set listLength to (count theList)
    if (listLength < 2) then return
    if (l < 0) then set l to listLength + l + 1
    if (r < 0) then set r to listLength + r + 1
    if (l > r) then set {l, r} to {r, l}
    
    script o
        property lst : theList
        property storage : missing value
    end script
    
    set rangeLength to r - l + 1
    set amount to (rangeLength + rangeLength - amount) mod rangeLength
    if (amount is 0) then return
    set o's storage to o's lst's items l thru (l + amount - 1)
    repeat with i from (l + amount) to r
        set o's lst's item (i - amount) to o's lst's item i
    end repeat
    set j to r - amount
    repeat with i from 1 to amount
        set o's lst's item (j + i) to o's storage's item i
    end repeat
end rotate

-- Task code:
local lst
set lst to {1, 2, 3, 4, 5, 6, 7, 8, 9}
-- Left-rotate all items (1 thru -1) by three places.
rotate(lst, 1, -1, -3)
return lst

Wholly in-place:

(* List range rotation, wholly in-place. Negative 'amount' = left rotation, positive = right.
    Method:
        Adjust the specified rotation amount to get a positive, < list length, left-rotation figure.
        If rotating by only 1 in either direction, do it in the obvious way.
        Otherwise reverse the range's leftmost 'amount' items, reverse the others, then reverse the lot.
*)
on rotate(theList, l, r, amount)
    set listLength to (count theList)
    if (listLength < 2) then return
    if (l < 0) then set l to listLength + l + 1
    if (r < 0) then set r to listLength + r + 1
    if (l > r) then set {l, r} to {r, l}
    
    script o
        property lst : theList
        
        on rotate1(a, z, step)
            set v to my lst's item a
            repeat with i from (a + step) to z by step
                set my lst's item (i - step) to my lst's item i
            end repeat
            set my lst's item z to v
        end rotate1
        
        on |reverse|(i, j)
            repeat with i from i to ((i + j - 1) div 2)
                set v to my lst's item i
                set my lst's item i to my lst's item j
                set my lst's item j to v
                set j to j - 1
            end repeat
        end |reverse|
    end script
    
    set rangeLength to r - l + 1
    set amount to (rangeLength + rangeLength - amount) mod rangeLength
    if (amount is 1) then
        tell o to rotate1(l, r, 1) -- Rotate left by 1.
    else if (amount = rangeLength - 1) then
        tell o to rotate1(r, l, -1) -- Rotate right by 1.
    else if (amount > 0) then
        tell o to |reverse|(l, l + amount - 1)
        tell o to |reverse|(l + amount, r)
        tell o to |reverse|(l, r)
    end if
end rotate

-- Task code:
local lst
set lst to {1, 2, 3, 4, 5, 6, 7, 8, 9}
-- Left-rotate all items (1 thru -1) by three places.
rotate(lst, 1, -1, -3)
return lst

Result in both cases:

Output:
{4, 5, 6, 7, 8, 9, 1, 2, 3}

Arturo

lst: [1 2 3 4 5 6 7 8 9]
print rotate.left lst 3
Output:
4 5 6 7 8 9 1 2 3

AutoHotkey

Shift_list_elements(Arr, dir, n){
    nums := Arr.Clone()
    loop % n
        if InStr(dir, "l")
            nums.Push(nums.RemoveAt(1))
        else
            nums.InsertAt(1, nums.RemoveAt(nums.count()))
    return nums
}
Examples:
Arr  := [1,2,3,4,5,6,7,8,9]
output1 := Shift_list_elements(Arr, "L", 3)
output2 := Shift_list_elements(Arr, "R", 3)
return
Output:
output1 = [4, 5, 6, 7, 8, 9, 1, 2, 3]
output2 = [7, 8, 9, 1, 2, 3, 4, 5, 6]

AWK

# syntax: GAWK -f SHIFT_LIST_ELEMENTS_TO_LEFT_BY_3.AWK
BEGIN {
    list = "1,2,3,4,5,6,7,8,9"
    printf("old: %s\n",list)
    printf("new: %s\n",shift_left(list,3))
    list = "a;b;c;d"
    printf("old: %s\n",list)
    printf("new: %s\n",shift_left(list,1,";"))
    exit(0)
}
function shift_left(str,n,sep,  i,left,right) {
    if (sep == "") {
      sep = ","
    }
    for (i=1; i<=n; i++) {
      left = substr(str,1,index(str,sep)-1)
      right = substr(str,index(str,sep)+1)
      str = right sep left
    }
    return(str)
}
Output:
old: 1,2,3,4,5,6,7,8,9
new: 4,5,6,7,8,9,1,2,3
old: a;b;c;d
new: b;c;d;a

BASIC

BASIC256

arraybase 1
global lista
dim lista(9)
lista[1] = 1
lista[2] = 2
lista[3] = 3
lista[4] = 4
lista[5] = 5
lista[6] = 6
lista[7] = 7
lista[8] = 8
lista[9] = 9

subroutine shiftLeft (lista)
	lo = lista[?,]
	hi = lista[?]
	first = lista[lo]
	for i = lo to hi-1
		lista[i] = lista[i + 1]
	next i
	lista[hi] = first
end subroutine

subroutine shiftLeftN (lista, n)
	for i = 1 to n
		call shiftLeft(lista)
	next i
end subroutine

call shiftLeftN(lista, 3)

for i = 1 to 9
	print lista[i];
	if i < 9 then print ", ";
next i
end
Output:
Igual que la entrada de FreeBASIC.

PureBasic

Global Dim lista.i(9)

DataSection
  Data.i 1,2,3,4,5,6,7,8,9
EndDataSection
For i.i = 1 To 9
  Read lista(i)
Next i

Procedure shiftLeft (lista)
  ;shifts list left by one step
  lo.i =  1 ;ArraySize(lista(), 1)
  hi.i =  ArraySize(lista())
  first.i = lista(lo)
  For i.i = lo To hi-1
    lista(i) = lista(i + 1)
  Next i
  lista(hi) = first
EndProcedure

Procedure shiftLeftN (lista, n)
  For i.i = 1 To n
    shiftLeft(lista)
  Next i
EndProcedure

OpenConsole()
shiftLeftN(lista, 3)

For i.i = 1 To 9
  Print(Str(lista(i)))
  If i < 9 : Print(", ") : EndIf
Next i
Input()
CloseConsole()
Output:
Igual que la entrada de FreeBASIC.

QBasic

DIM SHARED lista(1 TO 9)
DATA 1,2,3,4,5,6,7,8,9
FOR i = 1 TO 9
    READ lista(i)
NEXT i

SUB shiftLeft (lista())
    lo = LBOUND(lista)
    hi = UBOUND(lista)
    first = lista(lo)
    FOR i = lo TO hi
	lista(i) = lista(i + 1)
    NEXT i
    lista(hi) = first
END SUB

SUB shiftLeftN (lista(), n)
    FOR i = 1 TO n
	CALL shiftLeft(lista())
	NEXT i
END SUB

CALL shiftLeftN(lista(), 3)

FOR i = 1 TO 9
    PRINT lista(i);
    IF i < 9 THEN PRINT ", ";
NEXT i
END
Output:
Igual que la entrada de FreeBASIC.

BQN

data  1 + 9

3  data
Output:
⟨ 4 5 6 7 8 9 1 2 3 ⟩

C

Translation of: Wren
#include <stdio.h>

/* in place left shift by 1 */
void lshift(int *l, size_t n) {
    int i, f;
    if (n < 2) return;
    f = l[0];
    for (i = 0; i < n-1; ++i) l[i] = l[i+1];
    l[n-1] = f;
}

int main() {
    int l[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int i;
    size_t n = 9;
    printf("Original list     : ");
    for (i = 0; i < n; ++i) printf("%d ", l[i]);
    printf("\nShifted left by 3 : ");
    for (i = 0; i < 3; ++i) lshift(l, n);
    for (i = 0; i < n; ++i) printf("%d ", l[i]);
    printf("\n");
    return 0;
}
Output:
Original list     : 1 2 3 4 5 6 7 8 9 
Shifted left by 3 : 4 5 6 7 8 9 1 2 3 

C++

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

template <typename T>
void print(const std::vector<T>& v) {
    std::copy(v.begin(), v.end(), std::ostream_iterator<T>(std::cout, " "));
    std::cout << '\n';
}

int main() {
    std::vector<int> vec{1, 2, 3, 4, 5, 6, 7, 8, 9};
    std::cout << "Before: ";
    print(vec);
    std::rotate(vec.begin(), vec.begin() + 3, vec.end());
    std::cout << " After: ";
    print(vec);
}
Output:
Before: 1 2 3 4 5 6 7 8 9 
 After: 4 5 6 7 8 9 1 2 3 

CLU

% Shift an array left by a certain amount
shift_left = proc [T: type] (a: array[T], n: int)
    at = array[T]
    % shifting an empty array is a no-op
    if at$empty(a) then return end 
    
    % otherwise we take elements from the bottom
    % and put them at the top 
    low: int := at$low(a)
    for i: int in int$from_to(1, n) do
        at$addh(a, at$reml(a))
    end
    at$set_low(a, low)
end shift_left

show = proc (s: stream, a: array[int])
    for i: int in array[int]$elements(a) do
        stream$puts(s, int$unparse(i) || " ")
    end
    stream$putc(s,'\n')
end show

start_up = proc ()
    po: stream := stream$primary_output()
    arr: array[int] := array[int]$[1,2,3,4,5,6,7,8,9]
    
    stream$puts(po, "Before: ") show(po, arr)
    shift_left[int](arr, 3)
    stream$puts(po, " After: ") show(po, arr)
end start_up
Output:
Before: 1 2 3 4 5 6 7 8 9
 After: 4 5 6 7 8 9 1 2 3

Common Lisp

;; Load the alexandria library from the quicklisp repository
CL-USER> (ql:quickload "alexandria")

CL-USER> (alexandria:rotate '(1 2 3 4 5 6 7 8 9) -3)
(4 5 6 7 8 9 1 2 3)

Delphi

Library: Boost.Int

Boost.Int is part of DelphiBoostLib.

program Shift_list_elements_to_left_by_3;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  Boost.Int;

var
  List: TArray<Integer>;

begin
  List := [1, 2, 3, 4, 5, 6, 7, 8, 9];
  writeln('Original list     :', list.ToString);
  List.shift(3);
  writeln('Shifted left by 3 :', list.ToString);
  Readln;
end.
Output:
Original list     :[1, 2, 3, 4, 5, 6, 7, 8, 9]
Shifted left by 3 :[4, 5, 6, 7, 8, 9, 1, 2, 3]

Elixir

def rotate(enumerable, count) do
  {left, right} = Enum.split(enumerable, count)
  right ++ left
end

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

Euler

begin
    new shl; new shl3;

    shl  <- ` formal ls;
              if length ls < 2 then ls
                               else begin
                                        new L;
                                        L <- ls;
                                        tail L & ( L[ 1 ] )
                                    end
            ';
    shl3 <- ` formal ls; shl( shl( shl( ls ) ) ) ';

    out shl3( ( 1, 2, 3, 4, 5, 6, 7, 8 ) )
end
$

Excel

LAMBDA

Binding the name rotatedRow to the following lambda expression in the Name Manager of the Excel WorkBook:

(See LAMBDA: The ultimate Excel worksheet function)

rotatedRow
=LAMBDA(n,
    LAMBDA(xs,
        LET(
            nCols, COLUMNS(xs),
            m, MOD(n, nCols),
            x, SEQUENCE(
                1, nCols,
                1, 1
            ),
            d, nCols - m,

            IF(x > d,
                x - d,
                m + x
            )
        )
    )
)
Output:

The formula in cell B2 defines an array which populates the whole range B2:J2

fx =rotatedRow(3)(B1#)
A B C D E F G H I J
1 List 1 2 3 4 5 6 7 8 9
2 Rotated 4 5 6 7 8 9 1 2 3

Or, in terms of the MAKEARRAY function:

rotated
=LAMBDA(n,
    LAMBDA(xs,
        LET(
            nCols, COLUMNS(xs),
            m, MOD(n, nCols),
            d, nCols - m,
            
            MAKEARRAY(
                1, nCols,
                LAMBDA(
                    _, x,
                    IF(d < x,
                        x - d,
                        m + x
                    )
                )
            )
        )
    )
)
Output:
fx =rotated(3)(B1#)
A B C D E F G H I J
1 List 1 2 3 4 5 6 7 8 9
2 Rotated 4 5 6 7 8 9 1 2 3

F#

// Nigel Gallowy. March 29th., 2021
let fN=function _::_::_::n->n |_->raise(System.Exception("List has fewer than 3 elements"))
[[1..10];[1;2];[1;2;3]]|>Seq.iter(fun n->try printfn "%A->%A" n (fN n) with :? System.Exception as e->printfn "oops -> %s" (e.Message))
Output:
[1; 2; 3; 4; 5; 6; 7; 8; 9; 10]->[4; 5; 6; 7; 8; 9; 10]
oops -> List has fewer than 3 elements
[1; 2; 3]->[]

Factor

 USING: prettyprint sequences.extras ;

{ 1 2 3 4 5 6 7 8 9 } 3 rotate .
Output:
{ 4 5 6 7 8 9 1 2 3 }

You can also make a virtual rotated sequence. In other words, the underlying array remains the same, but the way it is indexed has been changed.

USING: arrays prettyprint sequences.rotated ;

{ 1 2 3 4 5 6 7 8 9 } 3 <rotated> >array .
Output:
{ 4 5 6 7 8 9 1 2 3 }

FreeBASIC

sub shift_left( list() as integer )
    'shifts list left by one step
    dim as integer lo = lbound(list), hi = ubound(list), first
    first = list(lo)
    for i as integer = lo to hi
        list(i) = list(i+1)
    next i
    list(hi) = first
    return
end sub

sub shift_left_n( list() as integer, n as uinteger )
    for i as uinteger = 1 to n
        shift_left( list() )
    next i
    return
end sub

dim as integer list(1 to 9) = {1,2,3,4,5,6,7,8,9}
shift_left_n( list(), 3 )
for i as integer = 1 to 9
    print list(i);
    if i<9 then print ", ";
next i
Output:
4, 5, 6, 7, 8, 9, 1, 2, 3

Go

Translation of: Wren
package main

import "fmt"

// in place left shift by 1
func lshift(l []int) {
    n := len(l)
    if n < 2 {
        return
    }
    f := l[0]
    for i := 0; i < n-1; i++ {
        l[i] = l[i+1]
    }
    l[n-1] = f
}

func main() {
    l := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("Original list     :", l)
    for i := 0; i < 3; i++ {
        lshift(l)
    }
    fmt.Println("Shifted left by 3 :", l)
}
Output:
Original list     : [1 2 3 4 5 6 7 8 9]
Shifted left by 3 : [4 5 6 7 8 9 1 2 3]

Haskell

------------- SHIFT LIST ELEMENTS TO LEFT BY N -----------

rotated :: Int -> [a] -> [a]
rotated n =
  ( (<*>) take
      . flip (drop . mod n)
      . cycle
  )
    <*> length

--------------------------- TEST -------------------------
main :: IO ()
main =
  let xs = [1 .. 9]
   in putStrLn ("Initial list: " <> show xs <> "\n")
        >> putStrLn "Rotated 3 or 30 positions to the left:"
        >> print (rotated 3 xs)
        >> print (rotated 30 xs)
        >> putStrLn "\nRotated 3 or 30 positions to the right:"
        >> print (rotated (-3) xs)
        >> print (rotated (-30) xs)
Output:
Initial list: [1,2,3,4,5,6,7,8,9]

Rotated 3 or 30 positions to the left:
[4,5,6,7,8,9,1,2,3]
[4,5,6,7,8,9,1,2,3]

Rotated 3 or 30 positions to the right:
[7,8,9,1,2,3,4,5,6]
[7,8,9,1,2,3,4,5,6]

J

   3 |. 1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3

However, while this matches the task example, it does not match the task title. In most contexts, a shift is different from a rotate:

   3 |.(!.0) 1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 0 0 0

Java

import java.util.List;
import java.util.Arrays;
import java.util.Collections;

public class RotateLeft {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        System.out.println("original: " + list);
        Collections.rotate(list, -3);
        System.out.println("rotated: " + list);
    }
}
Output:
original: [1, 2, 3, 4, 5, 6, 7, 8, 9]
rotated: [4, 5, 6, 7, 8, 9, 1, 2, 3]

JavaScript

(() => {
    "use strict";

    // -------- SHIFT LIST ELEMENTS TO LEFT BY 3 ---------

    // rotated :: Int -> [a] -> [a]
    const rotated = n =>
        // A rotation, n elements to the left,
        // of the input list.
        xs => 0 !== n ? (() => {
            const m = mod(n)(xs.length);

            return xs.slice(m).concat(
                xs.slice(0, m)
            );
        })() : Array.from(xs);


    // ---------------------- TEST -----------------------
    // main :: IO ()
    const main = () => {
        const xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];

        return [
                `    The input list: ${show(xs)}`,
                ` rotated 3 to left: ${show(rotated(3)(xs))}`,
                `     or 3 to right: ${show(rotated(-3)(xs))}`
            ]
            .join("\n");
    };

    // --------------------- GENERIC ---------------------

    // mod :: Int -> Int -> Int
    const mod = n =>
        // Inherits the sign of the *divisor* for non zero
        // results. Compare with `rem`, which inherits
        // the sign of the *dividend*.
        d => (n % d) + (
            signum(n) === signum(-d) ? (
                d
            ) : 0
        );


    // signum :: Num -> Num
    const signum = n =>
        0 > n ? (
            -1
        ) : (
            0 < n ? 1 : 0
        );


    // show :: a -> String
    const show = x =>
        JSON.stringify(x);

    // MAIN ---
    return main();
})();
Output:
    The input list: [1,2,3,4,5,6,7,8,9]
 rotated 3 to left: [4,5,6,7,8,9,1,2,3]
     or 3 to right: [7,8,9,1,2,3,4,5,6]

jq

Works with: jq

Works with gojq, the Go implementation of jq

# input should be an array or string
def rotateLeft($n):
   .[$n:] + .[:$n];

Examples:

[1, 2, 3, 4, 5, 6, 7, 8, 9] | rotateLeft(3) #=> [4,5,6,7,8,9,1,2,3]

"123456789" | rotateLeft(3) #=> "456789123"

Julia

list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
println(list, " => ", circshift(list, -3))
Output:
[1, 2, 3, 4, 5, 6, 7, 8, 9] => [4, 5, 6, 7, 8, 9, 1, 2, 3]

Mathematica/Wolfram Language

RotateLeft[{1, 2, 3, 4, 5, 6, 7, 8, 9}, 3]
Output:
{4, 5, 6, 7, 8, 9, 1, 2, 3}

Maxima

list:[1,2,3,4,5,6,7,8,9]$
append(rest(list,3),rest(list,-(length(list)-3)));
Output:
[4,5,6,7,8,9,1,2,3]

Nim

Using “rotatedLeft” from standard module “algorithm”. Note that its exists also “rotateLeft” for rotation in place.

import algorithm

let list = @[1, 2, 3, 4, 5, 6, 7, 8, 9]
echo list, " → ", rotatedLeft(list, 3)
Output:
@[1, 2, 3, 4, 5, 6, 7, 8, 9] → @[4, 5, 6, 7, 8, 9, 1, 2, 3]

OCaml

At the REPL:

# let rec rotate n = function
    | h :: (_ :: _ as t) when n > 0 -> rotate (pred n) (t @ [h])
    | l -> l
  ;;
val rotate : int -> 'a list -> 'a list = <fun>
# rotate 3 [1; 2; 3; 4; 5; 6; 7; 8; 9] ;;
- : int list = [4; 5; 6; 7; 8; 9; 1; 2; 3]

Perl

// 20210315 Perl programming solution

use strict;
use warnings;

my $n = 3;
my @list = 1..9;

push @list, splice @list, 0, $n;

print join ' ', @list, "\n"
Output:
4 5 6 7 8 9 1 2 3

Phix

sequence s = {1,2,3,4,5,6,7,8,9}
s = s[4..$]&s[1..3]
?s
Output:
{4,5,6,7,8,9,1,2,3}

PicoLisp

(let L (range 1 9)
   (println (conc (tail -3 L) (head 3 L))) )

PL/0

PL/0 has no data structures, not even arrays. This sample simulates an array using separate variables for each element. The simulated array is then used to represent the list.
The output shows the original list (one element per line) and the shifted list, separated by -111.
Note that PL/0 was intended as an educational tool for teaching compiler writing - so, e.g.: adding arrays might be an exercise for the students.

const maxlist = 8;
var   sub, v, l1, l2, l3, l4, l5, l6, l7, l8;
procedure getelement;
begin
  if sub = 1 then v := l1;
  if sub = 2 then v := l2;
  if sub = 3 then v := l3;
  if sub = 4 then v := l4;
  if sub = 5 then v := l5;
  if sub = 6 then v := l6;
  if sub = 7 then v := l7;
  if sub = 8 then v := l8;
end;
procedure setelement;
begin
  if sub = 1 then l1 := v;
  if sub = 2 then l2 := v;
  if sub = 3 then l3 := v;
  if sub = 4 then l4 := v;
  if sub = 5 then l5 := v;
  if sub = 6 then l6 := v;
  if sub = 7 then l7 := v;
  if sub = 8 then l8 := v;
end;
procedure shiftleft;
var   first;
begin
  sub   := 1;
  call getelement;
  first := v;
  sub   := 0;
  while sub < maxlist do begin
    sub := sub + 2;
    call getelement;
    sub := sub - 1;
    call setelement
  end;
  sub   := maxlist;
  v     := first;
  call setelement
end;
begin
  sub := 0;
  while sub < maxlist do begin
    sub := sub + 1;
    v   := sub;
    call setelement;
    ! v
  end;
  call shiftleft;
  call shiftleft;
  call shiftleft;
  ! -111;
  sub := 0;
  while sub < maxlist do begin
    sub := sub + 1;
    call getelement;
    ! v
  end
end.
Output:
          1
          2
          3
          4
          5
          6
          7
          8
       -111
          4
          5
          6
          7
          8
          1
          2
          3

Python

def rotate(list, n):
    for _ in range(n):
        list.append(list.pop(0))

    return list

# or, supporting opposite direction rotations:

def rotate(list, n):
    k = (len(list) + n) % len(list)
    return list[k::] + list[:k:]


list = [1,2,3,4,5,6,7,8,9]
print(list, " => ", rotate(list, 3))
Output:
[1, 2, 3, 4, 5, 6, 7, 8, 9]  =>  [4, 5, 6, 7, 8, 9, 1, 2, 3]


and we can also define rotated lists and ranges as slices taken from an infinite cycle of their values, after n initial items have been dropped:

'''Shift list elements to left by 3'''

from itertools import cycle, islice


# rotated :: Int -> [a] -> [a]
def rotated(n):
    '''A list rotated n elements to the left.'''
    def go(xs):
        lng = len(xs)
        stream = cycle(xs)

        # (n modulo lng) elements dropped from the start,
        list(islice(stream, n % lng))

        # and lng elements drawn from the remaining cycle.
        return list(islice(stream, lng))
    return go


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Positive and negative (left and right)
       rotations tested for list and range inputs.
    '''
    xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]

    print("List rotated 3 positions to the left:")
    print(
        rotated(3)(xs)
    )
    print("List rotated 3 positions to the right:")
    print(
        rotated(-3)(xs)
    )
    print("\nLists obtained by rotations of an input range:")
    rng = range(1, 1 + 9)
    print(
        rotated(3)(rng)
    )
    print(
        rotated(-3)(rng)
    )


# MAIN ---
if __name__ == '__main__':
    main()
Output:
List rotated 3 positions to the left:
[4, 5, 6, 7, 8, 9, 1, 2, 3]
List rotated 3 positions to the right:
[7, 8, 9, 1, 2, 3, 4, 5, 6]

Lists obtained by rotations of an input range:
[4, 5, 6, 7, 8, 9, 1, 2, 3]
[7, 8, 9, 1, 2, 3, 4, 5, 6]

Quackery

' [ 1 2 3 4 5 6 7 8 9 ] 3 split swap join echo
Output:
[ 4 5 6 7 8 9 1 2 3 ]

Raku

# 20210315 Raku programming solution

say [1..9].rotate(3)
Output:
(4 5 6 7 8 9 1 2 3)

REXX

/*REXX program  shifts  (using a rotate)  elements in a list  left  by some number  N.  */
parse arg n $ .                                  /*obtain optional arguments from the CL*/
if n=='' | n==","  then n= 3                     /*Not specified?  Then use the default.*/
if $=='' | $==","  then $= '[1,2,3,4,5,6,7,8,9]' /* "      "         "   "   "     "    */

$$= space( translate($, , '],[') )               /*convert literal list to bare list.   */
$$= '['translate( subword($$, N+1)  subword($$, 1, n), ',', " ")']'   /*rotate the list.*/

say 'shifting elements in the list by '  n       /*display action used on the input list*/
say ' input list='   $                           /*   "    the  input list ───► terminal*/
say 'output list='  $$                           /*   "    the output   "    "      "   */
output   when using the default inputs:
shifting elements in the list by  3
 input list= [1,2,3,4,5,6,7,8,9]
output list= [4,5,6,7,8,9,1,2,3]

Ring

see "working..." + nl

shift = [1,2,3,4,5,6,7,8,9]
lenshift = len(shift)
shiftNew = list(lenshift)
nshift = 3
temp = list(nshift)

see "original list:" + nl
showArray(shift)
see nl + "Shifted left by 3:" + nl

for n = 1 to nshift
    temp[n] = shift[n]
next

for n = 1 to lenshift - nshift
    shiftNew[n] = shift[n+nshift]
next

for n = lenshift-nshift+1 to lenshift
    shiftNew[n] = temp[n-lenshift+nshift]
next

showArray(shiftNew)

see nl + "done..." + nl

func showArray(array)
     txt = "["
     for n = 1 to len(array)
         txt = txt + array[n] + ", "
     next
     txt = left(txt,len(txt)-2)
     txt = txt + "]"
     see txt
Output:
working...
original list:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
shifted left by 3:
[4, 5, 6, 7, 8, 9, 1, 2, 3]
done...

RPL

Using the stack (idiomatic)

≪ LIST→ → size 
   ≪ 1 3 START size ROLL NEXT
      size →LIST
≫ ≫ 'SLL3' STO

Following Programming Pearls' Problem B algorithm

Works with: HP version 48G
3 DUP2 1 SWAP SUB REVLIST
   ROT ROT 1 + OVER SIZE SUB REVLIST
   + REVLIST
≫ ‘SLL3’ STO
{ 1 2 3 4 5 6 7 8 } SLL3
Output:
1: { 4 5 6 7 8 1 2 3 }

Ruby

Note, unlike some other languages, for Ruby's Array.rotate() method, a positive number means rotate to the left, while a negative number means rotate to the right. Use Array.rotate!() if you wish to mutate the original array rather than return a new one.

list = [1,2,3,4,5,6,7,8,9]
p list.rotate(3)
Output:
[4, 5, 6, 7, 8, 9, 1, 2, 3]

Rust

fn main() {
    let mut v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
    println!("Before: {:?}", v);
    v.rotate_left(3);
    println!(" After: {:?}", v);
}
Output:
Before: [1, 2, 3, 4, 5, 6, 7, 8, 9]
 After: [4, 5, 6, 7, 8, 9, 1, 2, 3]

Scheme

Works with: Chez Scheme
; Rotate a list by the given number of elements.
; Positive = Rotate left; Negative = Rotate right.

(define list-rotate
  (lambda (lst n)
    (cond
      ((or (not (pair? lst)) (= n 0))
        lst)
      ((< n 0)
        (let ((end (1- (length lst))))
          (list-rotate (append (list (list-ref lst end)) (list-head lst end)) (1+ n))))
      (else
        (list-rotate (cdr (append lst (list (car lst)))) (1- n))))))
Output:
(list-rotate '(1 2 3 4 5 6 7 8 9) 3) --> (4 5 6 7 8 9 1 2 3)
(list-rotate '(1 2 3 4 5 6 7 8 9) -3) --> (7 8 9 1 2 3 4 5 6)

sed

# rotate in 3 steps to easily work with lengths < 4
s/^\([^,]*\),\(.*\)/\2,\1/
s/^\([^,]*\),\(.*\)/\2,\1/
s/^\([^,]*\),\(.*\)/\2,\1/
Output:
$ echo 1,2,3,4,5,6,7,8,9 | sed -f rotate.sed
4,5,6,7,8,9,1,2,3

Wren

// in place left shift by 1
var lshift = Fn.new { |l|
    var n = l.count
    if (n < 2) return
    var f = l[0]
    for (i in 0..n-2) l[i] = l[i+1]
    l[-1] = f
}

var l = (1..9).toList
System.print("Original list     : %(l)")
for (i in 1..3) lshift.call(l)
System.print("Shifted left by 3 : %(l)")
Output:
Original list     : [1, 2, 3, 4, 5, 6, 7, 8, 9]
Shifted left by 3 : [4, 5, 6, 7, 8, 9, 1, 2, 3]


Library: Wren-seq

Alternatively, using a library method to produce the same output as before.

import "./seq" for Lst
 
var l = (1..9).toList
System.print("Original list     : %(l)")
System.print("Shifted left by 3 : %(Lst.lshift(l, 3))")

XPL0

int A, N, T, I;
[A:= [1, 2, 3, 4, 5, 6, 7, 8, 9];
for N:= 1 to 3 do  \rotate A left 3 places
    [T:= A(0);
    for I:= 0 to 9-2 do A(I):= A(I+1);
    A(I):= T];
for I:= 0 to 9-2 do
    [IntOut(0, A(I));  Text(0, ", ")];
IntOut(0, A(I));
]
Output:
4, 5, 6, 7, 8, 9, 1, 2, 3

Z80 Assembly

Zilog Z80

This example code will not work on the Game Boy, as the Game Boy does not have the RLD or RRD instructions.

The RLD instruction is a very peculiar one. It rotates leftward the bottom four bits of the accumulator with the byte pointed to by HL. For example, if A = &36 and (HL) = &BF, then a single RLD will result in A = &3B and (HL) = &F6. As it turns out, this can be used to rotate the entries in an array without using a ton of stack space.

PrintChar equ &BB5A ;address of Amstrad CPC firmware routine, writes accumulator to stdout.

org &1000
ld hl,myarray_end-1  ;HL must point to the last byte in the array.
ld b,9               ;byte count
call RLCA_RANGE

ld hl,myarray_end-1
ld b,9
call RLCA_RANGE

ld hl,myarray_end-1
ld b,9
call RLCA_RANGE

ld hl,myarray
jp PrintString
;ret

myarray:
;pre-convert these numbers to ascii so that the job is easier.
byte &31,&32,&33,&34,&35,&36,&37,&38,&39
myarray_end:
byte 0	;null terminator

RLCA_RANGE:		;DOESN'T WORK ON GAME BOY
;rotates a range of memory, e.g. &1000 = &23,&45,&67,&89 > &45,&67,&89,&23
;point HL at the end of the memory range this time.
	ld a,(hl)
	push hl
	push bc
loop_RLCA_RANGE_FIRST:
		RLD
		DEC HL
		djnz loop_RLCA_RANGE_FIRST
	pop bc
	pop hl
	
	push hl
	push bc
loop_RLCA_RANGE_SECOND:
		RLD
		DEC HL
		djnz loop_RLCA_RANGE_SECOND
	pop bc
	pop hl
	RLD
	ret

PrintString:
	ld a,(hl)
	or a
	ret z
	call PrintChar
	inc hl
	jr PrintString
Output:
456789123