Shift list elements to left by 3: Difference between revisions
(→{{header|Wren}}: Added alternative using library method.) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 10: | Line 10: | ||
{{trans|Python}} |
{{trans|Python}} |
||
< |
<syntaxhighlight lang="11l">F rotate(l, n) |
||
V k = (l.len + n) % l.len |
V k = (l.len + n) % l.len |
||
R l[k ..] [+] l[0 .< k] |
R l[k ..] [+] l[0 .< k] |
||
V l = [1, 2, 3, 4, 5, 6, 7, 8, 9] |
V l = [1, 2, 3, 4, 5, 6, 7, 8, 9] |
||
print(l‘ => ’rotate(l, 3))</ |
print(l‘ => ’rotate(l, 3))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 23: | Line 23: | ||
=={{header|Action!}}== |
=={{header|Action!}}== |
||
< |
<syntaxhighlight lang="action!">PROC PrintArray(INT ARRAY a INT size) |
||
INT i |
INT i |
||
Line 65: | Line 65: | ||
Test(a,9,-3) |
Test(a,9,-3) |
||
RETURN</ |
RETURN</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Shift_list_elements_to_left_by_3.png Screenshot from Atari 8-bit computer] |
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Shift_list_elements_to_left_by_3.png Screenshot from Atari 8-bit computer] |
||
Line 75: | Line 75: | ||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
Using slices and array concatenation. |
Using slices and array concatenation. |
||
< |
<syntaxhighlight lang="ada">with Ada.Text_Io; |
||
procedure Shift_Left is |
procedure Shift_Left is |
||
Line 101: | Line 101: | ||
Put_List (Shift); |
Put_List (Shift); |
||
end Shift_Left;</ |
end Shift_Left;</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> 1 2 3 4 5 6 7 8 9 |
<pre> 1 2 3 4 5 6 7 8 9 |
||
Line 107: | Line 107: | ||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
< |
<syntaxhighlight lang="algol68">BEGIN |
||
# shifts in place the elements of a left by n # |
# shifts in place the elements of a left by n # |
||
PRIO <<:= = 1; |
PRIO <<:= = 1; |
||
Line 140: | Line 140: | ||
PRINT v; |
PRINT v; |
||
print( ( newline ) ) |
print( ( newline ) ) |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 148: | Line 148: | ||
=={{header|ALGOL W}}== |
=={{header|ALGOL W}}== |
||
{{Trans|ALGOL 68}} |
{{Trans|ALGOL 68}} |
||
< |
<syntaxhighlight lang="pascal">begin |
||
% increments a and returns the new value % |
% increments a and returns the new value % |
||
integer procedure inc ( integer value result a ) ; begin a := a + 1; a end; |
integer procedure inc ( integer value result a ) ; begin a := a + 1; a end; |
||
Line 181: | Line 181: | ||
write() |
write() |
||
end |
end |
||
end.</ |
end.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 190: | Line 190: | ||
===Functional=== |
===Functional=== |
||
====Prefix appended==== |
====Prefix appended==== |
||
< |
<syntaxhighlight lang="applescript">------------- SHIFT LIST ELEMENTS TO LEFT BY 3 ----------- |
||
-- rotated :: Int -> [a] -> [a] |
-- rotated :: Int -> [a] -> [a] |
||
Line 307: | Line 307: | ||
set my text item delimiters to dlm |
set my text item delimiters to dlm |
||
s |
s |
||
end unlines</ |
end unlines</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre> Input list: {1, 2, 3, 4, 5, 6, 7, 8, 9} |
<pre> Input list: {1, 2, 3, 4, 5, 6, 7, 8, 9} |
||
Line 316: | Line 316: | ||
====Cycle sampled==== |
====Cycle sampled==== |
||
Another approach: drawing from an infinite list of cycles: |
Another approach: drawing from an infinite list of cycles: |
||
< |
<syntaxhighlight lang="applescript">------------- SHIFT LIST ELEMENTS TO LEFT BY 3 ----------- |
||
-- rotated :: Int -> [a] -> [a] |
-- rotated :: Int -> [a] -> [a] |
||
Line 511: | Line 511: | ||
set my text item delimiters to dlm |
set my text item delimiters to dlm |
||
s |
s |
||
end unlines</ |
end unlines</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre> Input list: {1, 2, 3, 4, 5, 6, 7, 8, 9} |
<pre> Input list: {1, 2, 3, 4, 5, 6, 7, 8, 9} |
||
Line 522: | Line 522: | ||
===Two in-place alternatives=== |
===Two in-place alternatives=== |
||
Fewest moves: |
Fewest moves: |
||
< |
<syntaxhighlight lang="applescript">(* List range rotation, in-place with temporary external storage. Negative 'amount' = left rotation, positive = right. |
||
Method: |
Method: |
||
Adjust the specified amount to get a positive, < list length, left-rotation figure. |
Adjust the specified amount to get a positive, < list length, left-rotation figure. |
||
Line 559: | Line 559: | ||
-- Left-rotate all items (1 thru -1) by three places. |
-- Left-rotate all items (1 thru -1) by three places. |
||
rotate(lst, 1, -1, -3) |
rotate(lst, 1, -1, -3) |
||
return lst</ |
return lst</syntaxhighlight> |
||
Wholly in-place: |
Wholly in-place: |
||
< |
<syntaxhighlight lang="applescript">(* List range rotation, wholly in-place. Negative 'amount' = left rotation, positive = right. |
||
Method: |
Method: |
||
Adjust the specified rotation amount to get a positive, < list length, left-rotation figure. |
Adjust the specified rotation amount to get a positive, < list length, left-rotation figure. |
||
Line 614: | Line 614: | ||
-- Left-rotate all items (1 thru -1) by three places. |
-- Left-rotate all items (1 thru -1) by three places. |
||
rotate(lst, 1, -1, -3) |
rotate(lst, 1, -1, -3) |
||
return lst</ |
return lst</syntaxhighlight> |
||
Result in both cases: |
Result in both cases: |
||
{{output}} |
{{output}} |
||
< |
<syntaxhighlight lang="applescript">{4, 5, 6, 7, 8, 9, 1, 2, 3}</syntaxhighlight> |
||
=={{header|Arturo}}== |
=={{header|Arturo}}== |
||
< |
<syntaxhighlight lang="rebol">lst: [1 2 3 4 5 6 7 8 9] |
||
print rotate.left lst 3</ |
print rotate.left lst 3</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 630: | Line 630: | ||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
< |
<syntaxhighlight lang="autohotkey">Shift_list_elements(Arr, dir, n){ |
||
nums := Arr.Clone() |
nums := Arr.Clone() |
||
loop % n |
loop % n |
||
Line 638: | Line 638: | ||
nums.InsertAt(1, nums.RemoveAt(nums.count())) |
nums.InsertAt(1, nums.RemoveAt(nums.count())) |
||
return nums |
return nums |
||
}</ |
}</syntaxhighlight> |
||
Examples:< |
Examples:<syntaxhighlight lang="autohotkey">Arr := [1,2,3,4,5,6,7,8,9] |
||
output1 := Shift_list_elements(Arr, "L", 3) |
output1 := Shift_list_elements(Arr, "L", 3) |
||
output2 := Shift_list_elements(Arr, "R", 3) |
output2 := Shift_list_elements(Arr, "R", 3) |
||
return</ |
return</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>output1 = [4, 5, 6, 7, 8, 9, 1, 2, 3] |
<pre>output1 = [4, 5, 6, 7, 8, 9, 1, 2, 3] |
||
Line 649: | Line 649: | ||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
<syntaxhighlight lang="awk"> |
|||
<lang AWK> |
|||
# syntax: GAWK -f SHIFT_LIST_ELEMENTS_TO_LEFT_BY_3.AWK |
# syntax: GAWK -f SHIFT_LIST_ELEMENTS_TO_LEFT_BY_3.AWK |
||
BEGIN { |
BEGIN { |
||
Line 671: | Line 671: | ||
return(str) |
return(str) |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 684: | Line 684: | ||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
==={{header|BASIC256}}=== |
==={{header|BASIC256}}=== |
||
< |
<syntaxhighlight lang="freebasic">arraybase 1 |
||
global lista |
global lista |
||
dim lista(9) |
dim lista(9) |
||
Line 720: | Line 720: | ||
next i |
next i |
||
end |
end |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 727: | Line 727: | ||
==={{header|PureBasic}}=== |
==={{header|PureBasic}}=== |
||
< |
<syntaxhighlight lang="purebasic">Global Dim lista.i(9) |
||
DataSection |
DataSection |
||
Line 761: | Line 761: | ||
Next i |
Next i |
||
Input() |
Input() |
||
CloseConsole()</ |
CloseConsole()</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 768: | Line 768: | ||
==={{header|QBasic}}=== |
==={{header|QBasic}}=== |
||
< |
<syntaxhighlight lang="qbasic">DIM SHARED lista(1 TO 9) |
||
DATA 1,2,3,4,5,6,7,8,9 |
DATA 1,2,3,4,5,6,7,8,9 |
||
FOR i = 1 TO 9 |
FOR i = 1 TO 9 |
||
Line 796: | Line 796: | ||
IF i < 9 THEN PRINT ", "; |
IF i < 9 THEN PRINT ", "; |
||
NEXT i |
NEXT i |
||
END</ |
END</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 805: | Line 805: | ||
=={{header|C}}== |
=={{header|C}}== |
||
{{trans|Wren}} |
{{trans|Wren}} |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
/* in place left shift by 1 */ |
/* in place left shift by 1 */ |
||
Line 827: | Line 827: | ||
printf("\n"); |
printf("\n"); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 836: | Line 836: | ||
=={{header|C++}}== |
=={{header|C++}}== |
||
< |
<syntaxhighlight lang="cpp">#include <algorithm> |
||
#include <iostream> |
#include <iostream> |
||
#include <iterator> |
#include <iterator> |
||
Line 854: | Line 854: | ||
std::cout << " After: "; |
std::cout << " After: "; |
||
print(vec); |
print(vec); |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 863: | Line 863: | ||
=={{header|CLU}}== |
=={{header|CLU}}== |
||
< |
<syntaxhighlight lang="clu">% Shift an array left by a certain amount |
||
shift_left = proc [T: type] (a: array[T], n: int) |
shift_left = proc [T: type] (a: array[T], n: int) |
||
at = array[T] |
at = array[T] |
||
Line 892: | Line 892: | ||
shift_left[int](arr, 3) |
shift_left[int](arr, 3) |
||
stream$puts(po, " After: ") show(po, arr) |
stream$puts(po, " After: ") show(po, arr) |
||
end start_up </ |
end start_up </syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>Before: 1 2 3 4 5 6 7 8 9 |
<pre>Before: 1 2 3 4 5 6 7 8 9 |
||
Line 898: | Line 898: | ||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">;; Load the alexandria library from the quicklisp repository |
||
CL-USER> (ql:quickload "alexandria") |
CL-USER> (ql:quickload "alexandria") |
||
CL-USER> (alexandria:rotate '(1 2 3 4 5 6 7 8 9) -3) |
CL-USER> (alexandria:rotate '(1 2 3 4 5 6 7 8 9) -3) |
||
(4 5 6 7 8 9 1 2 3)</ |
(4 5 6 7 8 9 1 2 3)</syntaxhighlight> |
||
=={{header|Delphi}}== |
=={{header|Delphi}}== |
||
Line 908: | Line 908: | ||
{{libheader| Boost.Int}} |
{{libheader| Boost.Int}} |
||
Boost.Int is part of [https://github.com/MaiconSoft/DelphiBoostLib DelphiBoostLib]. |
Boost.Int is part of [https://github.com/MaiconSoft/DelphiBoostLib DelphiBoostLib]. |
||
<syntaxhighlight lang="delphi"> |
|||
<lang Delphi> |
|||
program Shift_list_elements_to_left_by_3; |
program Shift_list_elements_to_left_by_3; |
||
Line 926: | Line 926: | ||
writeln('Shifted left by 3 :', list.ToString); |
writeln('Shifted left by 3 :', list.ToString); |
||
Readln; |
Readln; |
||
end.</ |
end.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>Original list :[1, 2, 3, 4, 5, 6, 7, 8, 9] |
<pre>Original list :[1, 2, 3, 4, 5, 6, 7, 8, 9] |
||
Line 939: | Line 939: | ||
{{Works with|Office 365 betas 2021}} |
{{Works with|Office 365 betas 2021}} |
||
< |
<syntaxhighlight lang="lisp">rotatedRow |
||
=LAMBDA(n, |
=LAMBDA(n, |
||
LAMBDA(xs, |
LAMBDA(xs, |
||
Line 957: | Line 957: | ||
) |
) |
||
) |
) |
||
)</ |
)</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
The formula in cell B2 defines an array which populates the whole range '''B2:J2''' |
The formula in cell B2 defines an array which populates the whole range '''B2:J2''' |
||
Line 1,003: | Line 1,003: | ||
Or, in terms of the MAKEARRAY function: |
Or, in terms of the MAKEARRAY function: |
||
< |
<syntaxhighlight lang="lisp">rotated |
||
=LAMBDA(n, |
=LAMBDA(n, |
||
LAMBDA(xs, |
LAMBDA(xs, |
||
Line 1,023: | Line 1,023: | ||
) |
) |
||
) |
) |
||
)</ |
)</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
{| class="wikitable" |
{| class="wikitable" |
||
Line 1,068: | Line 1,068: | ||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
< |
<syntaxhighlight lang="fsharp"> |
||
// Nigel Gallowy. March 29th., 2021 |
// Nigel Gallowy. March 29th., 2021 |
||
let fN=function _::_::_::n->n |_->raise(System.Exception("List has fewer than 3 elements")) |
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)) |
[[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)) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,081: | Line 1,081: | ||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
< |
<syntaxhighlight lang="factor"> USING: prettyprint sequences.extras ; |
||
{ 1 2 3 4 5 6 7 8 9 } 3 rotate .</ |
{ 1 2 3 4 5 6 7 8 9 } 3 rotate .</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,091: | Line 1,091: | ||
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. |
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. |
||
< |
<syntaxhighlight lang="factor">USING: arrays prettyprint sequences.rotated ; |
||
{ 1 2 3 4 5 6 7 8 9 } 3 <rotated> >array .</ |
{ 1 2 3 4 5 6 7 8 9 } 3 <rotated> >array .</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,100: | Line 1,100: | ||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
< |
<syntaxhighlight lang="freebasic">sub shift_left( list() as integer ) |
||
'shifts list left by one step |
'shifts list left by one step |
||
dim as integer lo = lbound(list), hi = ubound(list), first |
dim as integer lo = lbound(list), hi = ubound(list), first |
||
Line 1,123: | Line 1,123: | ||
print list(i); |
print list(i); |
||
if i<9 then print ", "; |
if i<9 then print ", "; |
||
next i</ |
next i</syntaxhighlight> |
||
{{out}}<pre>4, 5, 6, 7, 8, 9, 1, 2, 3</pre> |
{{out}}<pre>4, 5, 6, 7, 8, 9, 1, 2, 3</pre> |
||
=={{header|Go}}== |
=={{header|Go}}== |
||
{{trans|Wren}} |
{{trans|Wren}} |
||
< |
<syntaxhighlight lang="go">package main |
||
import "fmt" |
import "fmt" |
||
Line 1,151: | Line 1,151: | ||
} |
} |
||
fmt.Println("Shifted left by 3 :", l) |
fmt.Println("Shifted left by 3 :", l) |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,160: | Line 1,160: | ||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
< |
<syntaxhighlight lang="haskell">------------- SHIFT LIST ELEMENTS TO LEFT BY N ----------- |
||
rotated :: Int -> [a] -> [a] |
rotated :: Int -> [a] -> [a] |
||
Line 1,180: | Line 1,180: | ||
>> putStrLn "\nRotated 3 or 30 positions to the right:" |
>> putStrLn "\nRotated 3 or 30 positions to the right:" |
||
>> print (rotated (-3) xs) |
>> print (rotated (-3) xs) |
||
>> print (rotated (-30) xs)</ |
>> print (rotated (-30) xs)</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre>Initial list: [1,2,3,4,5,6,7,8,9] |
<pre>Initial list: [1,2,3,4,5,6,7,8,9] |
||
Line 1,193: | Line 1,193: | ||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java">import java.util.List; |
||
import java.util.Arrays; |
import java.util.Arrays; |
||
import java.util.Collections; |
import java.util.Collections; |
||
Line 1,205: | Line 1,205: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre>original: [1, 2, 3, 4, 5, 6, 7, 8, 9] |
<pre>original: [1, 2, 3, 4, 5, 6, 7, 8, 9] |
||
Line 1,211: | Line 1,211: | ||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
< |
<syntaxhighlight lang="javascript">(() => { |
||
"use strict"; |
"use strict"; |
||
Line 1,271: | Line 1,271: | ||
// MAIN --- |
// MAIN --- |
||
return main(); |
return main(); |
||
})();</ |
})();</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre> The input list: [1,2,3,4,5,6,7,8,9] |
<pre> The input list: [1,2,3,4,5,6,7,8,9] |
||
Line 1,280: | Line 1,280: | ||
{{works with|jq}} |
{{works with|jq}} |
||
'''Works with gojq, the Go implementation of jq''' |
'''Works with gojq, the Go implementation of jq''' |
||
< |
<syntaxhighlight lang="jq"># input should be an array or string |
||
def rotateLeft($n): |
def rotateLeft($n): |
||
.[$n:] + .[:$n];</ |
.[$n:] + .[:$n];</syntaxhighlight> |
||
Examples: |
Examples: |
||
<pre> |
<pre> |
||
Line 1,290: | Line 1,290: | ||
</pre> |
</pre> |
||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
< |
<syntaxhighlight lang="julia">list = [1, 2, 3, 4, 5, 6, 7, 8, 9] |
||
println(list, " => ", circshift(list, -3)) |
println(list, " => ", circshift(list, -3)) |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
[1, 2, 3, 4, 5, 6, 7, 8, 9] => [4, 5, 6, 7, 8, 9, 1, 2, 3] |
[1, 2, 3, 4, 5, 6, 7, 8, 9] => [4, 5, 6, 7, 8, 9, 1, 2, 3] |
||
Line 1,298: | Line 1,298: | ||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
< |
<syntaxhighlight lang="mathematica">RotateLeft[{1, 2, 3, 4, 5, 6, 7, 8, 9}, 3]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>{4, 5, 6, 7, 8, 9, 1, 2, 3}</pre> |
<pre>{4, 5, 6, 7, 8, 9, 1, 2, 3}</pre> |
||
Line 1,305: | Line 1,305: | ||
Using “rotatedLeft” from standard module “algorithm”. Note that its exists also “rotateLeft” for rotation in place. |
Using “rotatedLeft” from standard module “algorithm”. Note that its exists also “rotateLeft” for rotation in place. |
||
< |
<syntaxhighlight lang="nim">import algorithm |
||
let list = @[1, 2, 3, 4, 5, 6, 7, 8, 9] |
let list = @[1, 2, 3, 4, 5, 6, 7, 8, 9] |
||
echo list, " → ", rotatedLeft(list, 3)</ |
echo list, " → ", rotatedLeft(list, 3)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,314: | Line 1,314: | ||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">// 20210315 Perl programming solution |
||
use strict; |
use strict; |
||
Line 1,324: | Line 1,324: | ||
push @list, splice @list, 0, $n; |
push @list, splice @list, 0, $n; |
||
print join ' ', @list, "\n"</ |
print join ' ', @list, "\n"</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,331: | Line 1,331: | ||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
<!--< |
<!--<syntaxhighlight lang="phix">--> |
||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">}</span> |
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">}</span> |
||
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">4</span><span style="color: #0000FF;">..$]&</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">3</span><span style="color: #0000FF;">]</span> |
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">4</span><span style="color: #0000FF;">..$]&</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">3</span><span style="color: #0000FF;">]</span> |
||
<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span> |
<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span> |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,342: | Line 1,342: | ||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">(let L (range 1 9) |
||
(println (conc (tail -3 L) (head 3 L))) )</ |
(println (conc (tail -3 L) (head 3 L))) )</syntaxhighlight> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">def rotate(list, n): |
||
for _ in range(n): |
for _ in range(n): |
||
list.append(list.pop(0)) |
list.append(list.pop(0)) |
||
Line 1,361: | Line 1,361: | ||
list = [1,2,3,4,5,6,7,8,9] |
list = [1,2,3,4,5,6,7,8,9] |
||
print(list, " => ", rotate(list, 3)) |
print(list, " => ", rotate(list, 3)) |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
[1, 2, 3, 4, 5, 6, 7, 8, 9] => [4, 5, 6, 7, 8, 9, 1, 2, 3] |
[1, 2, 3, 4, 5, 6, 7, 8, 9] => [4, 5, 6, 7, 8, 9, 1, 2, 3] |
||
Line 1,369: | Line 1,369: | ||
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: |
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: |
||
< |
<syntaxhighlight lang="python">'''Shift list elements to left by 3''' |
||
from itertools import cycle, islice |
from itertools import cycle, islice |
||
Line 1,417: | Line 1,417: | ||
# MAIN --- |
# MAIN --- |
||
if __name__ == '__main__': |
if __name__ == '__main__': |
||
main()</ |
main()</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre>List rotated 3 positions to the left: |
<pre>List rotated 3 positions to the left: |
||
Line 1,430: | Line 1,430: | ||
=={{header|Quackery}}== |
=={{header|Quackery}}== |
||
< |
<syntaxhighlight lang="quackery">' [ 1 2 3 4 5 6 7 8 9 ] 3 split swap join echo</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,437: | Line 1,437: | ||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
<lang |
<syntaxhighlight lang="raku" line># 20210315 Raku programming solution |
||
say [1..9].rotate(3)</ |
say [1..9].rotate(3)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,446: | Line 1,446: | ||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
< |
<syntaxhighlight lang="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*/ |
parse arg n $ . /*obtain optional arguments from the CL*/ |
||
if n=='' | n=="," then n= 3 /*Not specified? Then use the default.*/ |
if n=='' | n=="," then n= 3 /*Not specified? Then use the default.*/ |
||
Line 1,456: | Line 1,456: | ||
say 'shifting elements in the list by ' n /*display action used on the input list*/ |
say 'shifting elements in the list by ' n /*display action used on the input list*/ |
||
say ' input list=' $ /* " the input list ───► terminal*/ |
say ' input list=' $ /* " the input list ───► terminal*/ |
||
say 'output list=' $$ /* " the output " " " */</ |
say 'output list=' $$ /* " the output " " " */</syntaxhighlight> |
||
{{out|output|text= when using the default inputs:}} |
{{out|output|text= when using the default inputs:}} |
||
<pre> |
<pre> |
||
Line 1,465: | Line 1,465: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
see "working..." + nl |
see "working..." + nl |
||
Line 1,502: | Line 1,502: | ||
txt = txt + "]" |
txt = txt + "]" |
||
see txt |
see txt |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,515: | Line 1,515: | ||
=={{header|Ruby}}== |
=={{header|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. |
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. |
||
< |
<syntaxhighlight lang="ruby">list = [1,2,3,4,5,6,7,8,9] |
||
p list.rotate(3) |
p list.rotate(3) |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre> |
<pre> |
||
[4, 5, 6, 7, 8, 9, 1, 2, 3] |
[4, 5, 6, 7, 8, 9, 1, 2, 3] |
||
Line 1,523: | Line 1,523: | ||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
< |
<syntaxhighlight lang="rust">fn main() { |
||
let mut v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9]; |
let mut v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9]; |
||
println!("Before: {:?}", v); |
println!("Before: {:?}", v); |
||
v.rotate_left(3); |
v.rotate_left(3); |
||
println!(" After: {:?}", v); |
println!(" After: {:?}", v); |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,537: | Line 1,537: | ||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
{{works with|Chez Scheme}} |
{{works with|Chez Scheme}} |
||
< |
<syntaxhighlight lang="scheme">; Rotate a list by the given number of elements. |
||
; Positive = Rotate left; Negative = Rotate right. |
; Positive = Rotate left; Negative = Rotate right. |
||
Line 1,549: | Line 1,549: | ||
(list-rotate (append (list (list-ref lst end)) (list-head lst end)) (1+ n)))) |
(list-rotate (append (list (list-ref lst end)) (list-head lst end)) (1+ n)))) |
||
(else |
(else |
||
(list-rotate (cdr (append lst (list (car lst)))) (1- n))))))</ |
(list-rotate (cdr (append lst (list (car lst)))) (1- n))))))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>(list-rotate '(1 2 3 4 5 6 7 8 9) 3) --> (4 5 6 7 8 9 1 2 3) |
<pre>(list-rotate '(1 2 3 4 5 6 7 8 9) 3) --> (4 5 6 7 8 9 1 2 3) |
||
Line 1,555: | Line 1,555: | ||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
< |
<syntaxhighlight lang="ecmascript">// in place left shift by 1 |
||
var lshift = Fn.new { |l| |
var lshift = Fn.new { |l| |
||
var n = l.count |
var n = l.count |
||
Line 1,567: | Line 1,567: | ||
System.print("Original list : %(l)") |
System.print("Original list : %(l)") |
||
for (i in 1..3) lshift.call(l) |
for (i in 1..3) lshift.call(l) |
||
System.print("Shifted left by 3 : %(l)")</ |
System.print("Shifted left by 3 : %(l)")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,577: | Line 1,577: | ||
{{libheader|Wren-seq}} |
{{libheader|Wren-seq}} |
||
Alternatively, using a library method to produce the same output as before. |
Alternatively, using a library method to produce the same output as before. |
||
< |
<syntaxhighlight lang="ecmascript">import "./seq" for Lst |
||
var l = (1..9).toList |
var l = (1..9).toList |
||
System.print("Original list : %(l)") |
System.print("Original list : %(l)") |
||
System.print("Shifted left by 3 : %(Lst.lshift(l, 3))")</ |
System.print("Shifted left by 3 : %(Lst.lshift(l, 3))")</syntaxhighlight> |
||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">int A, N, T, I; |
||
[A:= [1, 2, 3, 4, 5, 6, 7, 8, 9]; |
[A:= [1, 2, 3, 4, 5, 6, 7, 8, 9]; |
||
for N:= 1 to 3 do \rotate A left 3 places |
for N:= 1 to 3 do \rotate A left 3 places |
||
Line 1,593: | Line 1,593: | ||
[IntOut(0, A(I)); Text(0, ", ")]; |
[IntOut(0, A(I)); Text(0, ", ")]; |
||
IntOut(0, A(I)); |
IntOut(0, A(I)); |
||
]</ |
]</syntaxhighlight> |
||
{{out}} |
{{out}} |
Revision as of 14:00, 28 August 2022
- Task
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
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
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.
C
#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
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:
(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
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]
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 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}
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 = 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...
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
; 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 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]
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
- Draft Programming Tasks
- 11l
- Action!
- Ada
- ALGOL 68
- ALGOL W
- AppleScript
- Arturo
- AutoHotkey
- AWK
- BASIC
- BASIC256
- PureBasic
- QBasic
- C
- C++
- CLU
- Common Lisp
- Delphi
- System.SysUtils
- Boost.Int
- Excel
- F Sharp
- Factor
- FreeBASIC
- Go
- Haskell
- Java
- JavaScript
- Jq
- Julia
- Mathematica
- Wolfram Language
- Nim
- Perl
- Phix
- PicoLisp
- Python
- Quackery
- Raku
- REXX
- Ring
- Ruby
- Rust
- Scheme
- Wren
- Wren-seq
- XPL0