Shift list elements to left by 3: Difference between revisions

{{trans|Python}}

 

V k = (l.len + n) % l.len

R l[k ..] [+] l[0 .< k]

 

V l = [1, 2, 3, 4, 5, 6, 7, 8, 9]

 

{{out}}

 

=={{header|Action!}}==

INT i

 

 

Test(a,9,-3)

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

=={{header|Ada}}==

Using slices and array concatenation.

 

procedure Shift_Left is

 

Put_List (Shift);

{{out}}

<pre> 1 2 3 4 5 6 7 8 9

 

=={{header|ALGOL 68}}==

# shifts in place the elements of a left by n #

PRIO <<:= = 1;

PRINT v;

print( ( newline ) )

{{out}}

<pre>

=={{header|ALGOL W}}==

{{Trans|ALGOL 68}}

% increments a and returns the new value %

integer procedure inc ( integer value result a ) ; begin a := a + 1; a end;

write()

end

{{out}}

<pre>

===Functional===

====Prefix appended====

 

-- rotated :: Int -> [a] -> [a]

set my text item delimiters to dlm

s

{{Out}}

<pre> Input list: {1, 2, 3, 4, 5, 6, 7, 8, 9}

====Cycle sampled====

Another approach: drawing from an infinite list of cycles:

 

-- rotated :: Int -> [a] -> [a]

set my text item delimiters to dlm

s

{{Out}}

<pre> Input list: {1, 2, 3, 4, 5, 6, 7, 8, 9}

===Two in-place alternatives===

Fewest moves:

Method:

Adjust the specified amount to get a positive, < list length, left-rotation figure.

-- Left-rotate all items (1 thru -1) by three places.

rotate(lst, 1, -1, -3)

 

Wholly in-place:

Method:

Adjust the specified rotation amount to get a positive, < list length, left-rotation figure.

-- Left-rotate all items (1 thru -1) by three places.

rotate(lst, 1, -1, -3)

 

Result in both cases:

{{output}}

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|AutoHotkey}}==

nums := Arr.Clone()

loop % n

nums.InsertAt(1, nums.RemoveAt(nums.count()))

return nums

output1 := Shift_list_elements(Arr, "L", 3)

output2 := Shift_list_elements(Arr, "R", 3)

{{out}}

<pre>output1 = [4, 5, 6, 7, 8, 9, 1, 2, 3]

 

=={{header|AWK}}==

# syntax: GAWK -f SHIFT_LIST_ELEMENTS_TO_LEFT_BY_3.AWK

BEGIN {

return(str)

}

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|BASIC256}}===

global lista

dim lista(9)

next i

end

{{out}}

<pre>

 

==={{header|PureBasic}}===

 

DataSection

Next i

Input()

{{out}}

<pre>

 

==={{header|QBasic}}===

DATA 1,2,3,4,5,6,7,8,9

FOR i = 1 TO 9

IF i < 9 THEN PRINT ", ";

NEXT i

{{out}}

<pre>

=={{header|C}}==

{{trans|Wren}}

 

/* in place left shift by 1 */

printf("\n");

return 0;

 

{{out}}

 

=={{header|C++}}==

#include <iostream>

#include <iterator>

std::cout << " After: ";

print(vec);

 

{{out}}

 

=={{header|CLU}}==

shift_left = proc [T: type] (a: array[T], n: int)

at = array[T]

shift_left[int](arr, 3)

stream$puts(po, " After: ") show(po, arr)

{{out}}

<pre>Before: 1 2 3 4 5 6 7 8 9

 

=={{header|Common Lisp}}==

CL-USER> (ql:quickload "alexandria")

 

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

 

=={{header|Delphi}}==

{{libheader| Boost.Int}}

Boost.Int is part of [https://github.com/MaiconSoft/DelphiBoostLib DelphiBoostLib].

program Shift_list_elements_to_left_by_3;

 

writeln('Shifted left by 3 :', list.ToString);

Readln;

{{out}}

<pre>Original list :[1, 2, 3, 4, 5, 6, 7, 8, 9]

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(n,

LAMBDA(xs,

)

)

{{Out}}

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

 

Or, in terms of the MAKEARRAY function:

=LAMBDA(n,

LAMBDA(xs,

)

)

{{Out}}

{| class="wikitable"

 

=={{header|F_Sharp|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))

{{out}}

<pre>

 

=={{header|Factor}}==

 

{{out}}

<pre>

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.

 

 

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

'shifts list left by one step

dim as integer lo = lbound(list), hi = ubound(list), first

print list(i);

if i<9 then print ", ";

{{out}}<pre>4, 5, 6, 7, 8, 9, 1, 2, 3</pre>

=={{header|Go}}==

{{trans|Wren}}

 

import "fmt"

}

fmt.Println("Shifted left by 3 :", l)

 

{{out}}

 

=={{header|Haskell}}==

 

rotated :: Int -> [a] -> [a]

>> putStrLn "\nRotated 3 or 30 positions to the right:"

>> print (rotated (-3) xs)

{{Out}}

<pre>Initial list: [1,2,3,4,5,6,7,8,9]

 

=={{header|Java}}==

import java.util.Arrays;

import java.util.Collections;

}

}

{{Out}}

<pre>original: [1, 2, 3, 4, 5, 6, 7, 8, 9]

 

=={{header|JavaScript}}==

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre> The input list: [1,2,3,4,5,6,7,8,9]

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

def rotateLeft($n):

Examples:

<pre>

</pre>

=={{header|Julia}}==

println(list, " => ", circshift(list, -3))

<pre>

[1, 2, 3, 4, 5, 6, 7, 8, 9] => [4, 5, 6, 7, 8, 9, 1, 2, 3]

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>{4, 5, 6, 7, 8, 9, 1, 2, 3}</pre>

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

 

 

let list = @[1, 2, 3, 4, 5, 6, 7, 8, 9]

 

{{out}}

 

=={{header|Perl}}==

 

use strict;

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

 

{{out}}

<pre>

 

=={{header|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: #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>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

=={{header|Python}}==

for _ in range(n):

list.append(list.pop(0))

list = [1,2,3,4,5,6,7,8,9]

print(list, " => ", rotate(list, 3))

<pre>

[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:

 

 

from itertools import cycle, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>List rotated 3 positions to the left:

=={{header|Quackery}}==

 

 

{{out}}

 

=={{header|Raku}}==

 

{{out}}

<pre>

 

=={{header|REXX}}==

parse arg n $ . /*obtain optional arguments from the CL*/

if n=='' | n=="," then n= 3 /*Not specified? Then use the default.*/

say 'shifting elements in the list by ' n /*display action used on the input list*/

say ' input list=' $ /* " the input list ───► terminal*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

see "working..." + nl

 

txt = txt + "]"

see txt

{{out}}

<pre>

=={{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.

p list.rotate(3)

<pre>

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

 

=={{header|Rust}}==

let mut v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];

println!("Before: {:?}", v);

v.rotate_left(3);

println!(" After: {:?}", v);

 

{{out}}

=={{header|Scheme}}==

{{works with|Chez Scheme}}

; Positive = Rotate left; Negative = Rotate right.

 

(list-rotate (append (list (list-ref lst end)) (list-head lst end)) (1+ n))))

(else

{{out}}

<pre>(list-rotate '(1 2 3 4 5 6 7 8 9) 3) --> (4 5 6 7 8 9 1 2 3)

 

=={{header|Wren}}==

var lshift = Fn.new { |l|

var n = l.count

System.print("Original list : %(l)")

for (i in 1..3) lshift.call(l)

 

{{out}}

{{libheader|Wren-seq}}

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

var l = (1..9).toList

System.print("Original list : %(l)")

 

=={{header|XPL0}}==

[A:= [1, 2, 3, 4, 5, 6, 7, 8, 9];

for N:= 1 to 3 do \rotate A left 3 places

[IntOut(0, A(I)); Text(0, ", ")];

IntOut(0, A(I));

 

{{out}}