# HackerRank Arrays: Left Rotation problem solution

In this HackerRank Arrays: Left Rotation interview preparation kit problem you have Given an array a of n integers and a number, d, perform d left rotations on the array. Return the updated array to be printed as a single line of space-separated integers.

## Problem solution in Python programming.

```#!/bin/python3

import math
import os
import random
import re
import sys

# Complete the rotLeft function below.
def rotLeft(a, d):
a = list(a)
return a[d:] + a[:d]

if __name__ == '__main__':
fptr = open(os.environ['OUTPUT_PATH'], 'w')

nd = input().split()

n = int(nd[0])

d = int(nd[1])

a = list(map(int, input().rstrip().split()))

result = rotLeft(a, d)

fptr.write(' '.join(map(str, result)))
fptr.write('\n')

fptr.close()```

## Problem solution in Java Programming.

```import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

// Complete the rotLeft function below.
static int[] rotLeft(int[] a, int d) {
int length = a.length;
int j = 0;
int[] temp = new int[length];

for(int i = d; i < length; i++, j++) {
temp[j] = a[i];
}
if(j < length) {
for(int i = 0; i < d; i++, j++) {
temp[j] = a[i];
}
}

return temp;
}
private static final Scanner scanner = new Scanner(System.in);

public static void main(String[] args) throws IOException {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

String[] nd = scanner.nextLine().split(" ");

int n = Integer.parseInt(nd[0]);

int d = Integer.parseInt(nd[1]);

int[] a = new int[n];

String[] aItems = scanner.nextLine().split(" ");
scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");

for (int i = 0; i < n; i++) {
int aItem = Integer.parseInt(aItems[i]);
a[i] = aItem;
}

int[] result = rotLeft(a, d);

for (int i = 0; i < result.length; i++) {
bufferedWriter.write(String.valueOf(result[i]));

if (i != result.length - 1) {
bufferedWriter.write(" ");
}
}

bufferedWriter.newLine();

bufferedWriter.close();

scanner.close();
}
}```

### Problem solution in C++ programming.

```#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;

vector<int> array_left_rotation(vector<int> a, int n, int k) {
vector<int> output(n);
for (int i = 0; i < n; i++)
{
output[(i - k +n)%n] = a[i];
}

return output;
}
int main(){
int n;
int k;
cin >> n >> k;
vector<int> a(n);
for(int a_i = 0;a_i < n;a_i++){
cin >> a[a_i];
}
vector<int> output = array_left_rotation(a, n, k);
for(int i = 0; i < n;i++)
cout << output[i] << " ";
cout << endl;
return 0;
}```

### Problem solution in C programming.

```#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>

int main(){
int n;
int k;

int i, j;

scanf("%d %d",&n,&k);
int *a = malloc(sizeof(int) * n);
int *b = malloc(sizeof(int) * n);
for(int a_i = 0; a_i < n; a_i++){
scanf("%d",&b[a_i]);
}

for(i=0; i<n; i++){
j = ((i - k)% n + n) % n;
a[j] = b[i] ;
}
for(i=0; i<n; i++){
printf("%d ", a[i]);
}

free(a);
free(b);

return 0;
}```

### Problem solution in JavaScript programming.

```process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
input_stdin += data;
});

process.stdin.on('end', function () {
input_stdin_array = input_stdin.split("\n");
main();
});

return input_stdin_array[input_currentline++];
}

/////////////// ignore above this line ////////////////////

function main() {
var n = parseInt(n_temp[0]);
var k = parseInt(n_temp[1]);
a = a.map(Number);
console.log(a.slice(k).concat(a.slice(0, k)).join(' '));
}```

1. import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {

/*
* Complete the 'rotLeft' function below.
*
* The function is expected to return an INTEGER_ARRAY.
* The function accepts following parameters:
* 1. INTEGER_ARRAY a
* 2. INTEGER d
*/

public static List rotLeft(List a, int d) {

int n = a.size();
List temp = new ArrayList<>();

for(int i=0; i< n; i++){
temp.add(i, a.get(d+i < n ? d+i : Math.abs(n-d-i)));
}

return temp;
}

}

public class Solution {
public static void main(String[] args) throws IOException {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

int n = Integer.parseInt(firstMultipleInput[0]);

int d = Integer.parseInt(firstMultipleInput[1]);

.map(Integer::parseInt)
.collect(toList());

List result = Result.rotLeft(a, d);

bufferedWriter.write(
result.stream()
.map(Object::toString)
.collect(joining(" "))
+ "\n"
);