Pavol Pidanič - Page 2 of 27 - I can count to 1023 with 10 fingers

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 […]

Hackerrank – Migratory Birds

import scala.io.Source

object Solution extends App {
    val lines = Source.stdin.getLines().toList
    val birds = lines.tail.head.split(" ").map(_.toInt)

    val birdGroups = birds.groupBy(b => b).map(group => (group._1, group._2.length))
    val biggestGroup = birdGroups.foldLeft((0, 0))((maxBirdCountType, group) => {
    val birdType = group._1
    val birdTypeCount = group._2
    if(maxBirdCountType._2 < birdTypeCount) {
        (birdType, birdTypeCount)
    } else {
        maxBirdCountType
    }
    })

    println(biggestGroup._1)
}

import scala.io.Source

object Solution extends App {

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

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

val birdGroups = birds.groupBy(b => b).map(group => (group._1, group._2.length))

val biggestGroup = birdGroups.foldLeft((0, 0))((maxBirdCountType, group) => {

val birdType = group._1

val birdTypeCount = group._2

if(maxBirdCountType._2 < birdTypeCount) {

(birdType, birdTypeCount)

} else {

maxBirdCountType

}

})

println(biggestGroup._1)

}

Java

import java.util.*;

public class MigratoryBirds {

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

        Map<Integer, Integer> birdTypeCount = new HashMap<>();
        for(int i = 0; i < tests; i++) {
            int birdType = birdTypes[i];
            birdTypeCount.put(birdType, birdTypeCount.getOrDefault(birdType, 0) + 1);
        }

        Map.Entry<Integer, Integer> max = null;
        for(Map.Entry<Integer, Integer> birdCount : birdTypeCount.entrySet()) {
            int actualMax;
            if(max == null) {
                actualMax = 0;
            } else {
                actualMax = max.getValue();
            }
            if(birdCount.getValue() > actualMax) {
                max = birdCount;
            }
        }
        System.out.println(max.getKey());
        stdin.close();
    }
}

import java.util.*;

public class MigratoryBirds {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int tests = stdin.nextInt();

int[] birdTypes = new int[tests];

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

birdTypes[i] = stdin.nextInt();

}

Map<Integer, Integer> birdTypeCount = new HashMap<>();

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

int birdType = birdTypes[i];

birdTypeCount.put(birdType, birdTypeCount.getOrDefault(birdType, 0) + 1);

}

Map.Entry<Integer, Integer> max = null;

for(Map.Entry<Integer, Integer> birdCount : birdTypeCount.entrySet()) {

int actualMax;

if(max == null) {

actualMax = 0;

} else {

actualMax = max.getValue();

}

if(birdCount.getValue() > actualMax) {

max = birdCount;

}

System.out.println(max.getKey());

stdin.close();

}

Javascript

'use strict';

const processData = input => {
    const lines = input.split('\n');
    const birds = lines[1].split(' ').map(i => parseInt(i));
    const birdsCounts = [];
    for(let i = 0; i < birds.length; i++) {
        if(birdsCounts[birds[i]]) {
            birdsCounts[birds[i]] = ++birdsCounts[birds[i]];
        } else {
            birdsCounts[birds[i]] = 1
        }
    }

    let maxBirdType = 0;
    let maxBirdTypeCount = 0;
    for(let i = 0; i < birds.length; i++) {
        if(birdsCounts[birds[i]] > maxBirdTypeCount) {
            maxBirdTypeCount = birdsCounts[birds[i]];
            maxBirdType = birds[i]
        }
    }

    console.log(maxBirdType);
};

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 birds = lines[1].split(' ').map(i => parseInt(i));

const birdsCounts = [];

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

if(birdsCounts[birds[i]]) {

birdsCounts[birds[i]] = ++birdsCounts[birds[i]];

} else {

birdsCounts[birds[i]] = 1

}

let maxBirdType = 0;

let maxBirdTypeCount = 0;

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

if(birdsCounts[birds[i]] > maxBirdTypeCount) {

maxBirdTypeCount = birdsCounts[birds[i]];

maxBirdType = birds[i]

}

console.log(maxBirdType);

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

let _input = "";

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

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

Hackerrank – Mark and Toys

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution I started with sorting the toys prices ascending. I looked at the prices from the beginning and sum the prices. If I exceeded the required given sum, I outputed the amount of toys. I created solution in: Scala Java Javascript […]

Hackerrank – Electronics Shop

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution I do what is described in problem description. 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 extends App {
    val lines = Source.stdin.getLines().toList
    val (s, n, m) = lines.head.split(" ").map(_.toInt).toList match {
    case a :: b :: c :: Nil => (a, b, c)
    }
    val keyboards = lines(1).split(" ").map(_.toInt)
    val usbs = lines(2).split(" ").map(_.toInt)

    val allSmallerThanS = (for {
    i <- 0 until n
    j <- 0 until m
    } yield (i, j)).toList.filter {
    a => keyboards(a._1) + usbs(a._2) <= s
    }

    val sum = if(allSmallerThanS.isEmpty) {
    -1
    } else {
    val indexes = allSmallerThanS.maxBy {
        a => keyboards(a._1) + usbs(a._2)
    }
    keyboards(indexes._1) + usbs(indexes._2)
    }
    println(sum)
}

import scala.io.Source

object Solution extends App {

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

val (s, n, m) = lines.head.split(" ").map(_.toInt).toList match {

case a :: b :: c :: Nil => (a, b, c)

}

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

val usbs = lines(2).split(" ").map(_.toInt)

val allSmallerThanS = (for {

i <- 0 until n

j <- 0 until m

} yield (i, j)).toList.filter {

a => keyboards(a._1) + usbs(a._2) <= s

}

val sum = if(allSmallerThanS.isEmpty) {

-1

} else {

val indexes = allSmallerThanS.maxBy {

a => keyboards(a._1) + usbs(a._2)

}

keyboards(indexes._1) + usbs(indexes._2)

}

println(sum)

}

Java

import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int amount = stdin.nextInt();
        int keyboardCount = stdin.nextInt();
        int usbCount = stdin.nextInt();
        int[] keyboards = new int[keyboardCount];
        int[] usbs = new int[usbCount];
        for(int i = 0; i < keyboardCount; i++) {
            keyboards[i] = stdin.nextInt();
        }
        for(int i = 0; i < usbCount; i++) {
            usbs[i] = stdin.nextInt();
        }

        int spentAmount = -1;
        for(int i = 0; i < keyboardCount; i++) {
            for(int j = 0; j < usbCount; j++) {
                int sum = keyboards[i] + usbs[j];
                if(sum <= amount && sum > spentAmount) {
                    spentAmount = sum;
                }
            }
        }
        System.out.println(spentAmount);
        stdin.close();
    }
}

import java.util.*;

public class Solution {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int amount = stdin.nextInt();

int keyboardCount = stdin.nextInt();

int usbCount = stdin.nextInt();

int[] keyboards = new int[keyboardCount];

int[] usbs = new int[usbCount];

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

keyboards[i] = stdin.nextInt();

}

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

usbs[i] = stdin.nextInt();

}

int spentAmount = -1;

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

for(int j = 0; j < usbCount; j++) {

int sum = keyboards[i] + usbs[j];

if(sum <= amount && sum > spentAmount) {

spentAmount = sum;

}

System.out.println(spentAmount);

stdin.close();

}

Javascript

'use strict';

const processData = input => {
    const lines = input.split('\n');
    const [amount, keyboardCount, usbCount] = lines[0].split(' ').map(i => parseInt(i));
    const keyboards = lines[1].split(' ').map(i => parseInt(i));
    const usbs = lines[2].split(' ').map(i => parseInt(i));

    let spentAmount = -1;
    for(let i = 0; i < keyboardCount; i++) {
        for(let j = 0; j < usbCount; j++) {
            let sum = keyboards[i] + usbs[j];
            if(sum <= amount && sum > spentAmount) {
                spentAmount = sum;
            }
        }
    }
    console.log(spentAmount);
};

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 [amount, keyboardCount, usbCount] = lines[0].split(' ').map(i => parseInt(i));

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

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

let spentAmount = -1;

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

for(let j = 0; j < usbCount; j++) {

let sum = keyboards[i] + usbs[j];

if(sum <= amount && sum > spentAmount) {

spentAmount = sum;

}

console.log(spentAmount);

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

let _input = "";

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

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

Hackerrank – Day of the Programmer

object solution extends App {
    val sc = new java.util.Scanner (System.in)
    
    val year = sc.nextInt
    val output = if (year == 1918)
        "26.09.1918"
    else if (((year <= 1917) && (year%4 == 0)) || ((year%400 == 0) || ((year%4 ==0) & (year%100 != 0))))
        "12.09." + year
    else
        "13.09." + year
    
    println(output)
}

object solution extends App {

val sc = new java.util.Scanner (System.in)

val year = sc.nextInt

val output = if (year == 1918)

"26.09.1918"

else if (((year <= 1917) && (year%4 == 0)) || ((year%400 == 0) || ((year%4 ==0) & (year%100 != 0))))

"12.09." + year

else

"13.09." + year

println(output)

}

Java

import java.util.*;

public class Solution {

    static String solve(int year) {
        if (year == 1918)
            return "26.09.1918";
        else if (((year <= 1917) && (year%4 == 0)) || ((year%400 == 0) || ((year%4 ==0) & (year%100 != 0))))
            return "12.09." + year;
        else
            return "13.09." + year;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int year = in.nextInt();
        String result = solve(year);
        System.out.println(result);
    }
}

import java.util.*;

public class Solution {

static String solve(int year) {

if (year == 1918)

return "26.09.1918";

else if (((year <= 1917) && (year%4 == 0)) || ((year%400 == 0) || ((year%4 ==0) & (year%100 != 0))))

return "12.09." + year;

else

return "13.09." + year;

}

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int year = in.nextInt();

String result = solve(year);

System.out.println(result);

}

Javascript

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();    
});

function readLine() {
    return input_stdin_array[input_currentline++];
}

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

function solve(year){
    if (year == 1918)
        return "26.09.1918";
    else if (((year <= 1917) && (year%4 == 0)) || ((year%400 == 0) || ((year%4 ==0) & (year%100 != 0))))
        return "12.09." + year;
    else
        return "13.09." + year;
}

function main() {
    var year = parseInt(readLine());
    var result = solve(year);
    process.stdout.write(""+result+"\n");

}

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();

});

function readLine() {

return input_stdin_array[input_currentline++];

}

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

function solve(year){

if (year == 1918)

return "26.09.1918";

else if (((year <= 1917) && (year%4 == 0)) || ((year%400 == 0) || ((year%4 ==0) & (year%100 != 0))))

return "12.09." + year;

else

return "13.09." + year;

}

function main() {

var year = parseInt(readLine());

var result = solve(year);

process.stdout.write(""+result+"\n");

}

Hackerrank – Drawing Book

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution The equation to calculate no. of draws, when I started from the front of the book: no. of draws, when I started from the back of the book: if is even else […]

Hackerrank – String Compression

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

object Solution extends App {
  val line = Source.stdin.getLines().toList.head

  val subs = uniformSubstrings(line)
  val substringCompressed = subs.map(s => {
    val length = s.length
    if(length > 1) {
      s.head.toString + length
    } else {
      s.head.toString
    }
  })

  println(substringCompressed.mkString(""))


  def uniformSubstrings(s: String): List[String] = {
    if(s.length <= 0) {
      return Nil
    }
    val c = s.charAt(0)
    val substring = s.takeWhile(_ == c)
    substring :: uniformSubstrings(s.drop(substring.length))
  }
}

object Solution extends App {

val line = Source.stdin.getLines().toList.head

val subs = uniformSubstrings(line)

val substringCompressed = subs.map(s => {

val length = s.length

if(length > 1) {

s.head.toString + length

} else {

s.head.toString

}

})

println(substringCompressed.mkString(""))

def uniformSubstrings(s: String): List[String] = {

if(s.length <= 0) {

return Nil

}

val c = s.charAt(0)

val substring = s.takeWhile(_ == c)

substring :: uniformSubstrings(s.drop(substring.length))

}