# HackerRank Correctness and the Loop Invariant solution

In this HackerRank Correctness and the Loop Invariant problem, In the InsertionSort code below, there is an error. Can you fix it? Print the array only once, when it is fully sorted.

## Problem solution in Python programming.

```def insert_sort(A):
m = len(A)

for x in range(1,m):
k = A[x]
j=x
while(j>0 and A[j-1]>k):
A[j] = A[j-1]
j-=1

A[j]=k

return A

i = int(input())
N = [int(c) for c in input().split()]
N = insert_sort(N)

for a in N:
print(a, end=" ")
```

## Problem solution in Java Programming.

```import java.io.*;
import java.util.*;

public class Solution {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int numElements = in.nextInt();
int[] array = new int[numElements];
for (int i = 0; i < array.length; i++) {
array[i] = in.nextInt();
}

sort(array);
}

public static void sort(int[] array) {
for (int i = 1; i < array.length; i++) {
int index = i;
while (index > 0 && array[index] < array[index - 1]) {
int temp = array[index];
array[index] = array[index - 1];
array[index - 1] = temp;
index--;
}
}

printArray(array);
}

public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}

}```

### Problem solution in C++ programming.

```#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <assert.h>
#include <iostream>
using namespace std;
/* Head ends here */
void merge(int p[], int m, int q[], int n, int r[]){
for(int rb=0, pf=0,qf=0;rb<m+n;rb++){
if(pf<m&&qf<n){
if(p[pf]<=q[qf]){
r[rb]=p[pf];
pf++;
}
else{
r[rb]=q[qf];
qf++;
}
}
else if(pf<m){
r[rb]=p[pf];
pf++;
}
else{
r[rb]=q[qf];
qf++;
}
}
}

void mergesort(int*r,int n){
if(n>1){
int p[n/2],q[n-n/2];
for(int i=0;i<n/2;i++)p[i]=r[i];
for(int i=n/2;i<n;i++)q[i-n/2]=r[i];
mergesort(p,n/2);
mergesort(q,n-n/2);
merge(p,n/2,q,n-n/2,r);
}
}
/* Tail starts here */
int main(void) {

int _ar_size;
cin>>_ar_size;
int _ar[_ar_size], _ar_i;
for(_ar_i = 0; _ar_i < _ar_size; _ar_i++) {
cin>>_ar[_ar_i];
}

mergesort(_ar,_ar_size);

for(int i=0;i<_ar_size;i++)cout<<_ar[i]<<" ";
cout<<endl;
return 0;
}```

### Problem solution in C programming.

```#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <assert.h>
/* Head ends here */
#include <stddef.h>
void insertionSort(int ar_size, int *  ar) {
int i,j;
int value;
for(i=1;i<ar_size;i++)
{
value=ar[i];
j=i-1;
while(j>=0 && value<ar[j])
{
ar[j+1]=ar[j];
j=j-1;
}
ar[j+1]=value;
}
for(j=0;j<ar_size;j++)
{
printf("%d",ar[j]);
printf(" ");
}
}
/* Tail starts here */
int main(void) {
int _ar_size;
scanf("%d", &_ar_size);
int _ar[_ar_size], _ar_i;
for(_ar_i = 0; _ar_i < _ar_size; _ar_i++) {
scanf("%d", &_ar[_ar_i]);
}

insertionSort(_ar_size, _ar);

return 0;
}```

### Problem solution in JavaScript programming.

```function insertionSort (ar) {

for(i = 1; i < ar.length; i++){
var value = ar[i];
var prevIndex = i - 1;
while(prevIndex >= 0 && ar[prevIndex] > value){
ar[prevIndex + 1] = ar[prevIndex];
prevIndex--;
}
ar[prevIndex + 1] = value;
}
return ar;

}

function processData(input) {
var inputArray = input.split('\n');
var numArray = inputArray[1].split(" ");
for(var i=0;i<numArray.length;i++) {
numArray[i] = parseInt(numArray[i]);
}
console.log(insertionSort(numArray).join(" "));
}

process.stdin.resume();
process.stdin.setEncoding("ascii");
_input = "";
process.stdin.on("data", function (input) {
_input += input;
});

process.stdin.on("end", function () {
processData(_input);
});```