I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# 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.

Shift list elements to left by   3.

```      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)=tmpRETURN PROC ShiftLeftNTimes(INT ARRAY a INT size,times)  INT i   FOR i=1 TO times  DO    ShiftLeft(a,size)  ODRETURN 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:
```[1 2 3 4 5 6 7 8 9]
[4 5 6 7 8 9 1 2 3]
```

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()    endend.`
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 ifend 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 -> Inton |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 ifend |mod|  -- signum :: Num -> Numon signum(x)    if x < 0 then        -1    else if x = 0 then        0    else        1    end ifend signum  ------------------------ FORMATTING ---------------------- -- intercalate :: String -> [String] -> Stringon 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    send 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 tellend 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 ifend mReturn  -- showList :: [a] -> Stringon showList(xs)    "{" & intercalate(", ", map(my str, xs)) & "}"end showList  -- str :: a -> Stringon str(x)    x as stringend str  -- unlines :: [String] -> Stringon 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    send 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 scriptend cycle  -- drop :: Int -> [a] -> [a]-- drop :: Int -> String -> Stringon 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 ifend drop  -- mod :: Int -> Int -> Inton |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 ifend |mod|  -- signum :: Num -> Numon signum(x)    if x < 0 then        -1    else if x = 0 then        0    else        1    end ifend signum  -- take :: Int -> [a] -> [a]-- take :: Int -> String -> Stringon 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 ifend take  ------------------------ FORMATTING ---------------------- -- intercalate :: String -> [String] -> Stringon 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    send 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 tellend 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 ifend mReturn  -- showList :: [a] -> Stringon showList(xs)    "{" & intercalate(", ", map(my str, xs)) & "}"end showList  -- str :: a -> Stringon str(x)    x as stringend str  -- unlines :: [String] -> Stringon 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    send 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 repeatend rotate -- Task code:local lstset 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 ifend rotate -- Task code:local lstset 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.AWKBEGIN {    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 1global listadim lista(9)lista = 1lista = 2lista = 3lista = 4lista = 5lista = 6lista = 7lista = 8lista = 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] = firstend subroutine subroutine shiftLeftN (lista, n)	for i = 1 to n		call shiftLeft(lista)	next iend subroutine call shiftLeftN(lista, 3) for i = 1 to 9	print lista[i];	if i < 9 then print ", ";next iend `
Output:
```Igual que la entrada de FreeBASIC.
```

### PureBasic

`Global Dim lista.i(9) DataSection  Data.i 1,2,3,4,5,6,7,8,9EndDataSectionFor 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) = firstEndProcedure Procedure shiftLeftN (lista, n)  For i.i = 1 To n    shiftLeft(lista)  Next iEndProcedure OpenConsole()shiftLeftN(lista, 3) For i.i = 1 To 9  Print(Str(lista(i)))  If i < 9 : Print(", ") : EndIfNext iInput()CloseConsole()`
Output:
```Igual que la entrada de FreeBASIC.
```

### QBasic

`DIM SHARED lista(1 TO 9)DATA 1,2,3,4,5,6,7,8,9FOR 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) = firstEND SUB SUB shiftLeftN (lista(), n)    FOR i = 1 TO n	CALL shiftLeft(lista())	NEXT iEND SUB CALL shiftLeftN(lista(), 3) FOR i = 1 TO 9    PRINT lista(i);    IF i < 9 THEN PRINT ", ";NEXT iEND`
Output:
```Igual que la entrada de FreeBASIC.
```

## 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;    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 amountshift_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 repositoryCL-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]```

## Excel

### LAMBDA

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

`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

 =rotatedRow(3)(B1#) fx 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:
 =rotated(3)(B1#) fx 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., 2021let 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    returnend sub sub shift_left_n( list() as integer, n as uinteger )    for i as uinteger = 1 to n        shift_left( list() )    next i    returnend 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 1func lshift(l []int) {    n := len(l)    if n < 2 {        return    }    f := l    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]
```

`------------- 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]```

## 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 stringdef 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}`

## 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]`

## 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))) )`

## 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 = 3temp = list(nshift) see "original list:" + nlshowArray(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...
```

## 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)```

## Wren

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