Archívy Hackerrank - Stránka 20 z 26

Hackerrank – Filling Jars

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie sum = (b – a + 1) * no_candies Urob priemer a spodnú hranicu sum. Vytvoril som riešenie v týchto programovacích jazykoch: Java JavaScript Scala Ruby Všetky riešenia sú dostupné aj na mojom GitHub profile. Java

import java.math.BigInteger;
import java.util.*;
import java.math.BigInteger;

public class FillingJars {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int jars = stdin.nextInt();
        int operations = stdin.nextInt();
        BigInteger sum = BigInteger.ZERO;
        for(int i = 0; i < operations; i++) {
            BigInteger a = BigInteger.valueOf(stdin.nextLong());
            BigInteger b = BigInteger.valueOf(stdin.nextLong());
            BigInteger candies = BigInteger.valueOf(stdin.nextLong());
            sum = sum.add((b.subtract(a).add(BigInteger.ONE)).multiply(candies));
        }
        BigInteger avg = sum.divide(BigInteger.valueOf(jars));
        System.out.println(avg);
        stdin.close();
    }
}

import java.math.BigInteger;

import java.util.*;

import java.math.BigInteger;

public class FillingJars {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int jars = stdin.nextInt();

int operations = stdin.nextInt();

BigInteger sum = BigInteger.ZERO;

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

BigInteger a = BigInteger.valueOf(stdin.nextLong());

BigInteger b = BigInteger.valueOf(stdin.nextLong());

BigInteger candies = BigInteger.valueOf(stdin.nextLong());

sum = sum.add((b.subtract(a).add(BigInteger.ONE)).multiply(candies));

}

BigInteger avg = sum.divide(BigInteger.valueOf(jars));

System.out.println(avg);

stdin.close();

}

JavaScript

function processData(input) {
    var lines = input.split("\n");
    var head = lines[0].split(" ").map(i => parseInt(i));
    var jars = head[0];
    var operations = head[1];
    var sum = 0;
    for(var i = 1; i < lines.length; i++) {
        var nums = lines[i].split(" ").map(i => parseInt(i));
        var a = nums[0];
        var b = nums[1];
        var candies = nums[2];
        sum += (b - a + 1) * candies;
    }
    var avg = sum / jars;
    console.log(parseInt(Math.floor(avg)));
}

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

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

function processData(input) {

var lines = input.split("\n");

var head = lines[0].split(" ").map(i => parseInt(i));

var jars = head[0];

var operations = head[1];

var sum = 0;

for(var i = 1; i < lines.length; i++) {

var nums = lines[i].split(" ").map(i => parseInt(i));

var a = nums[0];

var b = nums[1];

var candies = nums[2];

sum += (b - a + 1) * candies;

}

var avg = sum / jars;

console.log(parseInt(Math.floor(avg)));

}

process.stdin.resume();

process.stdin.setEncoding("ascii");

_input = "";

process.stdin.on("data", function (input) {

_input += input;

});

process.stdin.on("end", function () {

processData(_input);

});

Scala

import scala.io.Source

object Solution extends App {
  val lines = Source.stdin.getLines().toList
  val jars = lines.head.split(" ").map(_.toInt).toList(0)
  val operations = lines.head.split(" ").map(_.toInt).toList(1)
  val description = lines.tail
  var sum = 0L
  description.foreach {
    line => {
      val ints = line.split(" ").map(_.toLong)
      val a = ints(0)
      val b = ints(1)
      val candies = ints(2)
      sum += ((b - a + 1) * candies)
    }
  }
  val avg = sum / jars
  println(avg)
}

import scala.io.Source

object Solution extends App {

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

val jars = lines.head.split(" ").map(_.toInt).toList(0)

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

val description = lines.tail

var sum = 0L

description.foreach {

line => {

val ints = line.split(" ").map(_.toLong)

val a = ints(0)

val b = ints(1)

val candies = ints(2)

sum += ((b - a + 1) * candies)

}

val avg = sum / jars

println(avg)

}

Ruby

(n_jars, operations) = gets.chomp.split.map { |i| i.to_i}
sum = 0
operations.times do
  (a, b, candies) = gets.chomp.split.map { |i| i.to_i}
  sum += ((b - a + 1) * candies)
end
average = sum.to_f / n_jars
answer = average.floor
puts answer

(n_jars, operations) = gets.chomp.split.map { |i| i.to_i}

sum = 0

operations.times do

(a, b, candies) = gets.chomp.split.map { |i| i.to_i}

sum += ((b - a + 1) * candies)

end

average = sum.to_f / n_jars

answer = average.floor

puts answer

Hackerrank – Fibonacci Numbers

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Použijeme rovnicu pre Fibonacciho čísla z popisu problému Fibonacci(n) = 0 , n = 1 Fibonacci(n) = 1 , n = 2 Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2) , n > 2 Vytvoril som riešenie v týchto programovacích jazykoch: Scala Všetky riešenia sú dostupné aj na […]

Hackerrank – Even Tree

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Vytvorime si hešmapu uzlov a uzlov, s ktorými sú prepojené. Iteruj cez mapu. Ak má i-tý uzol párny počet pripojených uzlov, iteruj cez pripojené uzly. Potom pre každý j-tý pripojený uzol, znovu zisti, či majú párny počet pripojených uzlov. Ak je nepárny, potom odstrihni uzol. […]

Hackerrank – Equations

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Riešenie podľa tohto alebo tohto. Vytvoril som riešenie v týchto programovacích jazykoch: Java JavaScript Ruby Scala Všetky riešenia sú dostupné aj na mojom GitHub profile. Java

import java.util.*;

public class Equations {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int n = stdin.nextInt();
        long result = 1;
        if(n == 1) {
            result = 1;
        } else {
            List<Integer> primes = eratosthenes(n);
            for(int i = 0; i < primes.size(); i++) {
                long prime = primes.get(i);
                long num = n;
                long exp = 0;
                while(num > 0) {
                    long div = num / prime;
                    num /= prime;
                    exp += div;
                }
                result *= (2 * exp + 1);
                result %= 1000007;
            }
        }
        System.out.println(result);
        stdin.close();
    }

    private static List<Integer> eratosthenes(int num) {
        List<Integer> result = new LinkedList<>();
        boolean[] primes = new boolean[num + 1];
        Arrays.fill(primes, true);
        for(int i = 2; i < primes.length; i++) {
            if (primes[i]) {
                long j = i;
                while (j * i < primes.length) {
                    primes[(int)j * i] = false;
                    j++;
                }
            }
        }
        for(int i = 2; i < primes.length; i++) {
            if (primes[i]) {
                result.add(i);
            }
        }
        return result;
    }
}

import java.util.*;

public class Equations {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int n = stdin.nextInt();

long result = 1;

if(n == 1) {

result = 1;

} else {

List<Integer> primes = eratosthenes(n);

for(int i = 0; i < primes.size(); i++) {

long prime = primes.get(i);

long num = n;

long exp = 0;

while(num > 0) {

long div = num / prime;

num /= prime;

exp += div;

}

result *= (2 * exp + 1);

result %= 1000007;

}

System.out.println(result);

stdin.close();

}

private static List<Integer> eratosthenes(int num) {

List<Integer> result = new LinkedList<>();

boolean[] primes = new boolean[num + 1];

Arrays.fill(primes, true);

for(int i = 2; i < primes.length; i++) {

if (primes[i]) {

long j = i;

while (j * i < primes.length) {

primes[(int)j * i] = false;

j++;

}

for(int i = 2; i < primes.length; i++) {

if (primes[i]) {

result.add(i);

}

return result;

}

JavaScript

'use strict';

var eratosthenes = num => {
    let result = [];
    let primes = Array(num + 1).fill(true);
    for(let i = 2; i < primes.length; i++) {
        if(primes[i]) {
            let j = i;
            while(j * i <= primes.length) {
                primes[j * i] = false;
                j++;
            }
        }
    }
    for(let i = 2; i < primes.length; i++) {
        if (primes[i]) {
            result.push(i);
        }
    }
    return result;
};

const processData = input => {
    let n = parseInt(input);
    let result = 1;
    if(n === 1)
        result = 1;
    else {
        let primes = eratosthenes(n);
        for(let i = 0; i < primes.length; i++) {
            let prime = primes[i];
            let num = n;
            let exp = 0;
            while(num > 0) {
                let div = parseInt(num / prime);
                num = (parseInt(num / prime));
                exp += div;
            }
            result *= (2 * exp + 1);
            result %= 1000007;
        }
    }
    console.log(result);
};

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

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

'use strict';

var eratosthenes = num => {

let result = [];

let primes = Array(num + 1).fill(true);

for(let i = 2; i < primes.length; i++) {

if(primes[i]) {

let j = i;

while(j * i <= primes.length) {

primes[j * i] = false;

j++;

}

for(let i = 2; i < primes.length; i++) {

if (primes[i]) {

result.push(i);

}

return result;

};

const processData = input => {

let n = parseInt(input);

let result = 1;

if(n === 1)

result = 1;

else {

let primes = eratosthenes(n);

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

let prime = primes[i];

let num = n;

let exp = 0;

while(num > 0) {

let div = parseInt(num / prime);

num = (parseInt(num / prime));

exp += div;

}

result *= (2 * exp + 1);

result %= 1000007;

}

console.log(result);

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

var _input = "";

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

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

Ruby

def eratosthenes(num)
  result = []
  primes = Array.new(num + 1, true)
  for i in 2..primes.length do
    if primes[i]
      j = i
      while j * i <= primes.length do
        primes[j * i] = false
        j += 1
      end
    end
  end
  for i in 2..primes.length do
    result << i if primes[i]
  end
  return result
end

input_fact = gets.chomp.to_i
result = 1
if input_fact == 1 
  result = 1
else
  primes = eratosthenes(input_fact)
  primes.each do |prime|
    num = input_fact
    exp = 0
    while num > 0 do
      div = num / prime
      num /= prime
      exp += div
    end
    result *= (2 * exp + 1)
   end
end
puts result % 1000007

def eratosthenes(num)

result = []

primes = Array.new(num + 1, true)

for i in 2..primes.length do

if primes[i]

j = i

while j * i <= primes.length do

primes[j * i] = false

j += 1

end

for i in 2..primes.length do

result << i if primes[i]

end

return result

end

input_fact = gets.chomp.to_i

result = 1

if input_fact == 1

result = 1

else

primes = eratosthenes(input_fact)

primes.each do |prime|

num = input_fact

exp = 0

while num > 0 do

div = num / prime

num /= prime

exp += div

end

result *= (2 * exp + 1)

end

puts result % 1000007

Scala

import scala.io.Source

object Equations extends App {
  val input = Source.stdin.getLines().toList(0).toInt

  val result: BigInt = if(input == 1) 1 else equations(input)
  println(result % 1000007)

  def sieveEratosthenes(limit: Int): Array[Int] = {
    val result = Array.fill(limit + 1)(true)
    for(i <- 2 until result.length) {
      if(result(i)) {
        var j: BigInt = i
        while(j * i < result.length) {
          result(j.toInt * i) = false
          j += 1
        }
      }
    }
    result.indices.filter(i => i > 1 && result(i) == true).toArray
  }

  def equations(input: Int): BigInt = {
    var result: BigInt = 1
    val primes = sieveEratosthenes(input)
    primes.foreach(prime => {
      var num = input
      var exp = 0
      while (num > 0) {
        val div = num / prime
        num /= prime
        exp += div
      }
      result *= (2 * exp + 1)
    })
    return result
  }
}

import scala.io.Source

object Equations extends App {

val input = Source.stdin.getLines().toList(0).toInt

val result: BigInt = if(input == 1) 1 else equations(input)

println(result % 1000007)

def sieveEratosthenes(limit: Int): Array[Int] = {

val result = Array.fill(limit + 1)(true)

for(i <- 2 until result.length) {

if(result(i)) {

var j: BigInt = i

while(j * i < result.length) {

result(j.toInt * i) = false

j += 1

}

result.indices.filter(i => i > 1 && result(i) == true).toArray

}

def equations(input: Int): BigInt = {

var result: BigInt = 1

val primes = sieveEratosthenes(input)

primes.foreach(prime => {

var num = input

var exp = 0

while (num > 0) {

val div = num / prime

num /= prime

exp += div

}

result *= (2 * exp + 1)

})

return result

}

Hackerrank – Detecting Valid Latitude and Longitude Pairs

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Môj regulárny výraz: \([+-]?((90(\.0+)?)|([1-8][0-9](\.[0-9]+)?)|([0-9](\.[0-9]+)?)),\s*[+-]?(((([1-9][0-9])|([0-9]))(\.[0-9]+)?)|(1((80(\.0+)?)|([0-7][0-9](\.[0-9]+)?))))\) Všetky riešenia sú dostupné aj na mojom GitHub profile.

Hackerrank – Detect HTML Tags

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Regex pre všetky tagy

Hackerrank – Detect HTML Attributes

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Vyparsuj všetky tagy, ktoré majú atribúty. Potom vyparsuj iba tagy a iba atribúty. Usporiadaj atribúty podľa toho, v akom tagu sa nachádzajú. Nakoniec už len usporiadať tagy a potom atribúty a vypísať výsledok. Vytvoril som riešenie v týchto programovacích jazykoch: Java Scala Všetky riešenia sú […]

Hackerrank – Connecting Towns

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Všetky trasy je súčin trás medzi jednotlivými mestami. Vytvoril som riešenie v týchto programovacích jazykoch: Java JavaScript Scala Ruby Všetky riešenia sú dostupné aj na mojom GitHub profile. Java

import java.util.Scanner;

public class ConnectingTowns {
    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int cases = stdin.nextInt();
        for(int i = 0; i < cases; i++) {
            int l = stdin.nextInt();
            int routes = 1;
            for(int j = 0; j < l - 1; j++) {
                routes *= stdin.nextInt();
                routes %= 1234567;
            }
            System.out.println(routes);
        }
        stdin.close();
    }
}

import java.util.Scanner;

public class ConnectingTowns {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int cases = stdin.nextInt();

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

int l = stdin.nextInt();

int routes = 1;

for(int j = 0; j < l - 1; j++) {

routes *= stdin.nextInt();

routes %= 1234567;

}

System.out.println(routes);

}

stdin.close();

}

JavaScript

function processData(input) {
    var lines = input.split('\n');
    var n = parseInt(lines[0]);
    var index = 2;
    for(var i = 0; i < n; i++) {
        var arr = lines[index].split(" ").map(i => parseInt(i));
        var routes = 1;
        for(var j = 0; j < arr.length; j++) {
            routes *= arr[j];
            routes %= 1234567;
        }
        console.log(routes);
        index += 2;
    }
}

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

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

function processData(input) {

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

var n = parseInt(lines[0]);

var index = 2;

for(var i = 0; i < n; i++) {

var arr = lines[index].split(" ").map(i => parseInt(i));

var routes = 1;

for(var j = 0; j < arr.length; j++) {

routes *= arr[j];

routes %= 1234567;

}

console.log(routes);

index += 2;

}

process.stdin.resume();

process.stdin.setEncoding("ascii");

_input = "";

process.stdin.on("data", function (input) {

_input += input;

});

process.stdin.on("end", function () {

processData(_input);

});

Scala

import scala.io.Source

object ConnectingTowns extends App {
  val lines = Source.stdin.getLines().drop(1)
  val routesArray = lines.toList.filter(_.contains(" "))
  val routes = routesArray.map(_.split(" ").map(_.toLong).foldLeft(1L)(_ * _ % 1234567))
  println(routes.mkString("\n"))
}

import scala.io.Source

object ConnectingTowns extends App {

val lines = Source.stdin.getLines().drop(1)

val routesArray = lines.toList.filter(_.contains(" "))

val routes = routesArray.map(_.split(" ").map(_.toLong).foldLeft(1L)(_ * _ % 1234567))

println(routes.mkString("\n"))

}

Ruby

cases = gets.chomp.to_i
cases.times do
  result = 1
  towns = gets.chomp.to_i
  routes = gets.chomp.split.map { |e| e.to_i }
  for i in 0..towns - 2 do
    result *= routes[i]
    result %= 1234567
  end
  puts result 
end

cases = gets.chomp.to_i

cases.times do

result = 1

towns = gets.chomp.to_i

routes = gets.chomp.split.map { |e| e.to_i }

for i in 0..towns - 2 do

result *= routes[i]

result %= 1234567

end

puts result

end

Hackerrank – Computing the GCD

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Využil som známy Euklidov algoritmus. Vytvoril som riešenie v týchto programovacích jazykoch: Scala Všetky riešenia sú dostupné aj na mojom GitHub profile. Scala

object ComputingGcd {
    
   def gcd(x: Int, y: Int): Int =
   {
     if(y == 0) x else gcd(y, x % y)
   }
  

   /**This part handles the input/output. Do not change or modify it **/
  def acceptInputAndComputeGCD(pair:List[Int]) = {
      println(gcd(pair.head,pair.reverse.head))
  } 

    def main(args: Array[String]) {
/** The part relates to the input/output. Do not change or modify it **/
         acceptInputAndComputeGCD(readLine().trim().split(" ").map(x=>x.toInt).toList)

    }
}

object ComputingGcd {

def gcd(x: Int, y: Int): Int =

{

if(y == 0) x else gcd(y, x % y)

}

/**This part handles the input/output. Do not change or modify it **/

def acceptInputAndComputeGCD(pair:List[Int]) = {

println(gcd(pair.head,pair.reverse.head))

}

def main(args: Array[String]) {

/** The part relates to the input/output. Do not change or modify it **/

acceptInputAndComputeGCD(readLine().trim().split(" ").map(x=>x.toInt).toList)

}

Hackerrank – Common Child

Popis problému Celý popis zadania sa nacháza – Hackerrank. Riešenie Implementácia je podľa algoritmu Longest Common Subsequence Problem. Riešenie v ruby je implementované rovnakým spôsobom ako riešenie v Jave. Avšak jeden test v ruby mi neprešiel kvôli timeout. Vytvoril som riešenie v týchto programovacích jazykoch: Java Ruby Všetky riešenia sú dostupné aj na mojom GitHub […]

Pavol Pidanič

Dokážem na 10 prstoch napočítať do 1023

Kategória: Hackerrank

Hackerrank – Filling Jars

Hackerrank – Fibonacci Numbers

Hackerrank – Even Tree

Hackerrank – Equations

Hackerrank – Detecting Valid Latitude and Longitude Pairs

Hackerrank – Detect HTML Tags

Hackerrank – Detect HTML Attributes

Hackerrank – Connecting Towns

Hackerrank – Computing the GCD

Hackerrank – Common Child