Archives Hackerrank - Pavol Pidanič

Hackerrank – Making Anagrams

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution First, I have found common characters in both strings (intersection of characters) and calculate the count. Then I haves substracted string one length and intersection chars count. Similar way substraction of string 2 length and intersection chars count. The result […]

Hackerrank – Insertion Sort – Part 2

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Look at the implementation. I created solution in: Java All solutions are also available on my GitHub profile. Java

import java.util.*;

public class Solution {

    public static void insertionSortPart2(int[] ar) {
        for(int i = 1; i < ar.length; i++) {
            int num = ar[i];
            int swapPos = i - 1;
            int l = i - 1;
            boolean isSwap = false;
            while(l >= 0) {
                if(num < ar[l]) {
                    isSwap = true;
                    swapPos = l;
                    l--;
                } else {
                    break;
                }
            }
            if(isSwap) {
                for(int j = i - 1; j >= swapPos ; j--) {
                    ar[j + 1] = ar[j];
                }
                ar[swapPos] = num;
            }
            printArray(ar);
        }
    }

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

    }
    private static void printArray(int[] ar) {
        for(int n: ar){
            System.out.print(n+" ");
        }
        System.out.println("");
    }
}

import java.util.*;

public class Solution {

public static void insertionSortPart2(int[] ar) {

for(int i = 1; i < ar.length; i++) {

int num = ar[i];

int swapPos = i - 1;

int l = i - 1;

boolean isSwap = false;

while(l >= 0) {

if(num < ar[l]) {

isSwap = true;

swapPos = l;

l--;

} else {

break;

}

if(isSwap) {

for(int j = i - 1; j >= swapPos ; j--) {

ar[j + 1] = ar[j];

}

ar[swapPos] = num;

}

printArray(ar);

}

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int s = in.nextInt();

int[] ar = new int[s];

for(int i=0;i<s;i++){

ar[i]=in.nextInt();

}

insertionSortPart2(ar);

}

private static void printArray(int[] ar) {

for(int n: ar){

System.out.print(n+" ");

}

System.out.println("");

}

Hackerrank – Counting Sort 1

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Look at the implementation. I created solution in: Scala Java Javascript All solutions are also available on my GitHub profile. Scala

import scala.io.Source

object Solution{
    def countingSort(arr: Array[Int]): Array[Int] =  {
        val countsOfNumbers = arr.sorted.groupBy(i => i).map(a => (a._1, a._2.length))

        (0 until 100).map(countsOfNumbers.getOrElse(_, 0)).toArray
    }

    def main(args: Array[String]) {
        val lines = Source.stdin.getLines().toList
        val arr = lines.tail.head.split(" ").map(_.toInt)
        val result = countingSort(arr)
        println (result.mkString(" "))
    }
}

import scala.io.Source

object Solution{

def countingSort(arr: Array[Int]): Array[Int] = {

val countsOfNumbers = arr.sorted.groupBy(i => i).map(a => (a._1, a._2.length))

(0 until 100).map(countsOfNumbers.getOrElse(_, 0)).toArray

}

def main(args: Array[String]) {

val lines = Source.stdin.getLines().toList

val arr = lines.tail.head.split(" ").map(_.toInt)

val result = countingSort(arr)

println (result.mkString(" "))

}

Java

import java.util.*;

public class Solution {

    static int[] countingSort(int[] arr) {
        int[] counts = new int[100];
        for(int i = 0; i < arr.length; i++) {
            counts[arr[i]]++;
        }
        return counts;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n];
        for(int arr_i = 0; arr_i < n; arr_i++){
            arr[arr_i] = in.nextInt();
        }
        int[] result = countingSort(arr);
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i] + (i != result.length - 1 ? " " : ""));
        }
        System.out.println("");


        in.close();
    }
}

import java.util.*;

public class Solution {

static int[] countingSort(int[] arr) {

int[] counts = new int[100];

for(int i = 0; i < arr.length; i++) {

counts[arr[i]]++;

}

return counts;

}

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

int[] arr = new int[n];

for(int arr_i = 0; arr_i < n; arr_i++){

arr[arr_i] = in.nextInt();

}

int[] result = countingSort(arr);

for (int i = 0; i < result.length; i++) {

System.out.print(result[i] + (i != result.length - 1 ? " " : ""));

}

System.out.println("");

in.close();

}

Javascript

'use strict';

const counting = (arr) => {
    const counts = []
    for(let i = 0; i < 100; i++) {
        counts[i] = 0;
    }
    for(let i = 0; i < arr.length; i++) {
        counts[arr[i]]++;
    }

    console.log(counts.join(' '));
}

const processData = input => {
    const lines = input.split('\n');
    const arr  = lines[1].split(' ').map(i => parseInt(i));
    counting(arr);
};

process.stdin.resume();
process.stdin.setEncoding("ascii");

let _input = "";
process.stdin.on("data", input => _input += input);
process.stdin.on("end", () => processData(_input));

'use strict';

const counting = (arr) => {

const counts = []

for(let i = 0; i < 100; i++) {

counts[i] = 0;

}

for(let i = 0; i < arr.length; i++) {

counts[arr[i]]++;

}

console.log(counts.join(' '));

}

const processData = input => {

const lines = input.split('\n');

const arr = lines[1].split(' ').map(i => parseInt(i));

counting(arr);

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

let _input = "";

process.stdin.on("data", input => _input += input);

process.stdin.on("end", () => processData(_input));

Hackerrank – Separate the Numbers

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution I explain my solution with following examples: Example 1234 I start with a beginning of a string, which would be one digit number – 1 and try to examine a rest of the given string 234. Next, I check the […]

Hackerrank – Two Characters

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution I started with finding all unique characters. Then I created all possible combinations of pairs. I deleted other characters except the pair. I found if the examined pair contains alternating characters in deleted strings If yes I count the length […]

Hackerrank – Counting Valleys

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution I loop throught all steps and remeber the level from the sea (level). If it is D, I decrement by 1, if U increment by 1. When such situation happen that actual sea level is 0 and current step is […]

Hackerrank – Cats and a Mouse

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Cats and the mouse moves with the same speed. Suppose it is by 1 on x-axis. Lets define the difference between their positions: (cat A, mouse), (cat B, mouse). where , , […]

Hackerrank – Breaking the Records

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Look at the implementation. The steps are in problem description. I created solution in: Scala Java Javascript All solutions are also available on my GitHub profile. Scala

import scala.io.Source
    
object Solution extends App {
    val lines = Source.stdin.getLines().toList
    val points = lines.tail.head.split(" ").map(_.toInt)
    var mostPoints = points.head
    var leastPoints = points.head
    var mostPointsBreak = 0
    var leastPointsBreak = 0
    
    points.foreach(point => {
        if(point > mostPoints) {
          mostPoints = point
          mostPointsBreak += 1
        }
        if(point < leastPoints) {
          leastPoints = point
          leastPointsBreak += 1
        }
    })
    
    println(mostPointsBreak + " " + leastPointsBreak)
}

import scala.io.Source

object Solution extends App {

val lines = Source.stdin.getLines().toList

val points = lines.tail.head.split(" ").map(_.toInt)

var mostPoints = points.head

var leastPoints = points.head

var mostPointsBreak = 0

var leastPointsBreak = 0

points.foreach(point => {

if(point > mostPoints) {

mostPoints = point

mostPointsBreak += 1

}

if(point < leastPoints) {

leastPoints = point

leastPointsBreak += 1

}

})

println(mostPointsBreak + " " + leastPointsBreak)

}

Java

import java.util.*;

public class BreakingTheRecords {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int tests = stdin.nextInt();
        long[] records = new long[tests];
        for(int i = 0; i < tests; i++) {
            records[i] = stdin.nextLong();
        }

        long mostPoints = records[0];
        long leastPoints = records[0];
        int mostPointsBreak = 0;
        int leastPointsBreak = 0;
        for(int i = 1; i < tests; i++) {
            long points = records[i];
            if(points > mostPoints) {
                mostPoints = points;
                mostPointsBreak += 1;
            }
            if(points < leastPoints) {
                leastPoints = points;
                leastPointsBreak += 1;
            }
        }

        System.out.println(mostPointsBreak + " " + leastPointsBreak);
        stdin.close();
    }
}

import java.util.*;

public class BreakingTheRecords {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int tests = stdin.nextInt();

long[] records = new long[tests];

for(int i = 0; i < tests; i++) {

records[i] = stdin.nextLong();

}

long mostPoints = records[0];

long leastPoints = records[0];

int mostPointsBreak = 0;

int leastPointsBreak = 0;

for(int i = 1; i < tests; i++) {

long points = records[i];

if(points > mostPoints) {

mostPoints = points;

mostPointsBreak += 1;

}

if(points < leastPoints) {

leastPoints = points;

leastPointsBreak += 1;

}

System.out.println(mostPointsBreak + " " + leastPointsBreak);

stdin.close();

}

Javascript

'use strict';

const processData = input => {
    const lines = input.split('\n');
    const records = lines[1].split(' ').map(i => parseInt(i));

    let mostPoints = records[0];
    let leastPoints = records[0];
    let mostPointsBreak = 0;
    let leastPointsBreak = 0;
    for(let i = 1; i < records.length; i++) {
        let points = records[i];
        if(points > mostPoints) {
            mostPoints = points;
            mostPointsBreak += 1;
        }
        if(points < leastPoints) {
            leastPoints = points;
            leastPointsBreak += 1;
        }
    }

    console.log(mostPointsBreak + ' ' + leastPointsBreak);
};

process.stdin.resume();
process.stdin.setEncoding("ascii");

let _input = "";
process.stdin.on("data", input => _input += input);
process.stdin.on("end", () => processData(_input));

'use strict';

const processData = input => {

const lines = input.split('\n');

const records = lines[1].split(' ').map(i => parseInt(i));

let mostPoints = records[0];

let leastPoints = records[0];

let mostPointsBreak = 0;

let leastPointsBreak = 0;

for(let i = 1; i < records.length; i++) {

let points = records[i];

if(points > mostPoints) {

mostPoints = points;

mostPointsBreak += 1;

}

if(points < leastPoints) {

leastPoints = points;

leastPointsBreak += 1;

}

console.log(mostPointsBreak + ' ' + leastPointsBreak);

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

let _input = "";

process.stdin.on("data", input => _input += input);

process.stdin.on("end", () => processData(_input));

Hackerrank – Birthday Chocolate

import scala.io.Source

object Solution extends App {
    val lines = Source.stdin.getLines().toList
    val bars = lines(1).split(" ").map(_.toInt).toList
    val dm = lines(2).split(" ").map(_.toInt).toList match {
    case i :: j :: Nil => (i, j)
    }

    val allConsecutives = bars.sliding(dm._2)
    val result = allConsecutives.count(bars => bars.sum == dm._1)

    println(result)
}

import scala.io.Source

object Solution extends App {

val lines = Source.stdin.getLines().toList

val bars = lines(1).split(" ").map(_.toInt).toList

val dm = lines(2).split(" ").map(_.toInt).toList match {

case i :: j :: Nil => (i, j)

}

val allConsecutives = bars.sliding(dm._2)

val result = allConsecutives.count(bars => bars.sum == dm._1)

println(result)

}

Java

import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int tests = stdin.nextInt();
        int[] bars = new int[tests];
        for(int i = 0; i < tests; i++) {
            bars[i] = stdin.nextInt();
        }
        int d = stdin.nextInt();
        int m = stdin.nextInt();

        int result = 0;
        for(int i = 0; i < bars.length - m + 1; i++) {
            int sum = 0;
            for(int j = i; j < i + m; j++) {
                sum += bars[j];
            }
            if(sum == d) {
                result++;
            }
        }

        System.out.println(result);
        stdin.close();
    }
}

import java.util.*;

public class Solution {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int tests = stdin.nextInt();

int[] bars = new int[tests];

for(int i = 0; i < tests; i++) {

bars[i] = stdin.nextInt();

}

int d = stdin.nextInt();

int m = stdin.nextInt();

int result = 0;

for(int i = 0; i < bars.length - m + 1; i++) {

int sum = 0;

for(int j = i; j < i + m; j++) {

sum += bars[j];

}

if(sum == d) {

result++;

}

System.out.println(result);

stdin.close();

}

Javascript

'use strict';

const processData = input => {
    const lines = input.split('\n');
    const bars = lines[1].split(' ').map(i => parseInt(i));
    const [d, m] = lines[2].split(' ').map(i => parseInt(i));

    let result = 0;
    for(let i = 0; i < bars.length - m + 1; i++) {
        let sum = 0;
        for(let j = i; j < i + m; j++) {
            sum += bars[j];
        }
        if(sum == d) {
            result++;
        }
    }
    console.log(result);
};

process.stdin.resume();
process.stdin.setEncoding("ascii");

let _input = "";
process.stdin.on("data", input => _input += input);
process.stdin.on("end", () => processData(_input));

'use strict';

const processData = input => {

const lines = input.split('\n');

const bars = lines[1].split(' ').map(i => parseInt(i));

const [d, m] = lines[2].split(' ').map(i => parseInt(i));

let result = 0;

for(let i = 0; i < bars.length - m + 1; i++) {

let sum = 0;

for(let j = i; j < i + m; j++) {

sum += bars[j];

}

if(sum == d) {

result++;

}

console.log(result);

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

let _input = "";

process.stdin.on("data", input => _input += input);

process.stdin.on("end", () => processData(_input));

Hackerrank – Picking Numbers

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution First, I started with sorting the array. I took 0th index as a pointer. I had the second pointer as 1st index. I incremented second pointer and tried to find out if the difference between values at the pointers is […]

Pavol Pidanič

I can count to 1023 with 10 fingers

Category: Hackerrank

Hackerrank – Making Anagrams

Hackerrank – Insertion Sort – Part 2

Hackerrank – Counting Sort 1

Hackerrank – Separate the Numbers

Hackerrank – Two Characters

Hackerrank – Counting Valleys

Hackerrank – Cats and a Mouse

Hackerrank – Breaking the Records

Hackerrank – Birthday Chocolate

Hackerrank – Picking Numbers