January 2016 - Page 6 of 8

Hackerrank – Flowers

Problem Statement A description of the problem can be found on Hackerrank. Solution Sort all prices descending. The formula for calculating the flower i in prices: $$total = \sum_{i=0}^{n-1}((i / k + 1) * price_{i})$$ I created solution in: Java JavaScript Ruby Scala All solutions are also available on my GitHub. Java

import java.util.*;

public class Flowers {

    private static class Descending implements Comparator<Integer> {
        @Override
        public int compare(Integer i, Integer j) {
            return j - i;
        }
    }

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int n = stdin.nextInt();
        int k = stdin.nextInt();
        Integer[] prices = new Integer[n];
        for(int i = 0; i < n; i++) {
            prices[i] = stdin.nextInt();
        }
        Arrays.sort(prices, new Descending());
        int sum = 0;
        for(int i = 0; i < n; i++) {
            int factor = i / k;
            sum += prices[i] * (factor + 1);
        }
        System.out.println(sum);
        stdin.close();
    }
}

import java.util.*;

public class Flowers {

private static class Descending implements Comparator<Integer> {

@Override

public int compare(Integer i, Integer j) {

return j - i;

}

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int n = stdin.nextInt();

int k = stdin.nextInt();

Integer[] prices = new Integer[n];

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

prices[i] = stdin.nextInt();

}

Arrays.sort(prices, new Descending());

int sum = 0;

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

int factor = i / k;

sum += prices[i] * (factor + 1);

}

System.out.println(sum);

stdin.close();

}

JavaScript

'use strict';

const processData = input => {
    let lines = input.split('\n');
    let definition = lines[0].split(' ').map(i => parseInt(i));
    let n = definition[0];
    let k = definition[1];
    let prices = lines[1].split(" ").map(i => parseInt(i));
    let descendingPrices = prices.sort((i, j) => j - i);
    let totalPrice = 0;
    for(let i = 0; i < n; i++) {
        let factor = parseInt(i / k);
        totalPrice += (factor + 1) * descendingPrices[i];
    }
    console.log(totalPrice);

};

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

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

'use strict';

const processData = input => {

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

let definition = lines[0].split(' ').map(i => parseInt(i));

let n = definition[0];

let k = definition[1];

let prices = lines[1].split(" ").map(i => parseInt(i));

let descendingPrices = prices.sort((i, j) => j - i);

let totalPrice = 0;

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

let factor = parseInt(i / k);

totalPrice += (factor + 1) * descendingPrices[i];

}

console.log(totalPrice);

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

var _input = "";

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

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

[…]

Hackerrank – Flipping Bits

Problem Statement A description of the problem can be found on Hackerrank. Solution Define maximum unsigned int in binary as: 11 111 111 111 111 111 111 111 111 111 111. For all input number XOR with maximum and print the output. Aware that some programming languages have signed numbers. It is better to use […]

Hackerrank – Find Point

Problem Statement A description of the problem can be found on Hackerrank. Solution For solution you can check wikipedia page for Point reflection. I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. Java

import java.util.*;

public class FindPoint {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int points = stdin.nextInt();
        for(int i = 0; i < points; i++) {
            int x = stdin.nextInt();
            int y = stdin.nextInt();
            int mx = stdin.nextInt();
            int my = stdin.nextInt();
            int sx = 2 * mx - x;
            int sy = 2 * my - y;
            System.out.println(sx + " " + sy);
        }
        stdin.close();
    }
}

import java.util.*;

public class FindPoint {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int points = stdin.nextInt();

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

int x = stdin.nextInt();

int y = stdin.nextInt();

int mx = stdin.nextInt();

int my = stdin.nextInt();

int sx = 2 * mx - x;

int sy = 2 * my - y;

System.out.println(sx + " " + sy);

}

stdin.close();

}

JavaScript

function processData(input) {
    var lines = input.split("\n");
    //var points = parseInt(lines[0]);
    for(var i = 1; i < lines.length; i++) {
        var coordinates = lines[i].split(" ").map(i => parseInt(i));
        var x = coordinates[0];
        var y = coordinates[1];
        var mx = coordinates[2];
        var my = coordinates[3];
        var sx = 2 * mx - x;
        var sy = 2 * my - y;
        console.log(sx + " " + sy);
    }
}

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 points = parseInt(lines[0]);

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

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

var x = coordinates[0];

var y = coordinates[1];

var mx = coordinates[2];

var my = coordinates[3];

var sx = 2 * mx - x;

var sy = 2 * my - y;

console.log(sx + " " + sy);

}

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

case class Point(val x: Int, val y: Int) {
  def reflection(midPoint: Point): Point = {
    val rx = 2 * midPoint.x - x
    val ry = 2 * midPoint.y - y
    Point(rx, ry)
  }
}

object FindPoint extends App {
  val coordinates = Source.stdin.getLines().drop(1)
  coordinates.foreach {
    lines => {
      val ints = lines.split(" ").map(_.toInt)
      val point = Point(ints(0), ints(1))
      val midPoint = Point(ints(2), ints(3))
      val symmetricPoint = point.reflection(midPoint)
      println(s"${symmetricPoint.x} ${symmetricPoint.y}")
    }
  }
}

import scala.io.Source

case class Point(val x: Int, val y: Int) {

def reflection(midPoint: Point): Point = {

val rx = 2 * midPoint.x - x

val ry = 2 * midPoint.y - y

Point(rx, ry)

}

object FindPoint extends App {

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

coordinates.foreach {

lines => {

val ints = lines.split(" ").map(_.toInt)

val point = Point(ints(0), ints(1))

val midPoint = Point(ints(2), ints(3))

val symmetricPoint = point.reflection(midPoint)

println(s"${symmetricPoint.x} ${symmetricPoint.y}")

}

Ruby

class Point
  attr_reader :x, :y
  
  def initialize(x, y)
    @x = x
    @y = y
  end

  def self.symetric_point(point, midpoint)
    x = 2 * midpoint.x - point.x
    y = 2 * midpoint.y - point.y
    return Point.new(x, y)
  end
end


tests = gets.chomp.to_i
tests.times do
  coordinates = gets.chomp.split.map { |e| e.to_i }
  half1 = coordinates.slice(0..1)
  half2 = coordinates.slice(2..3)
  point = Point.new(half1[0], half1[1])
  midpoint = Point.new(half2[0], half2[1])
  
  symetric_point = Point.symetric_point(point, midpoint)
  puts "#{symetric_point.x} #{symetric_point.y}"
end

class Point

attr_reader :x, :y

def initialize(x, y)

@x = x

@y = y

end

def self.symetric_point(point, midpoint)

x = 2 * midpoint.x - point.x

y = 2 * midpoint.y - point.y

return Point.new(x, y)

end

tests = gets.chomp.to_i

tests.times do

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

half1 = coordinates.slice(0..1)

half2 = coordinates.slice(2..3)

point = Point.new(half1[0], half1[1])

midpoint = Point.new(half2[0], half2[1])

symetric_point = Point.symetric_point(point, midpoint)

puts "#{symetric_point.x} #{symetric_point.y}"

end

Hackerrank – Find Hackerrank

Problem Statement A description of the problem can be found on Hackerrank. Solution Print “0” if the input matches ^hackerrank$ or ^hackerrank.*hackerrank$ Print “1” if the input matches ^hackerrank.* Print “2” if the input matches .*hackerrank$ else print “-1” I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. […]

Hackerrank – Find Digits

Problem Statement A description of the problem can be found on Hackerrank. Solution Count all digits if the digit is greatest than 0 and if the input is divisible by digit. I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. Java

import java.util.Scanner;

public class FindDigits 
{
    public static void main(String[] args)
    {
        Scanner stdin = new Scanner(System.in);
        int tests = Integer.parseInt(stdin.nextLine());
        for(int i = 0; i < tests; i++)
        {
            int result = 0;
            String number = stdin.nextLine();
            for(char digit : number.toCharArray())
            {
                if(Character.getNumericValue(digit) != 0 
                        && Integer.parseInt(number) % Character.getNumericValue(digit) == 0)
                {
                    result++;
                }
            }
            System.out.println(result);
        }
        stdin.close();
    }
}

import java.util.Scanner;

public class FindDigits

{

public static void main(String[] args)

{

Scanner stdin = new Scanner(System.in);

int tests = Integer.parseInt(stdin.nextLine());

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

{

int result = 0;

String number = stdin.nextLine();

for(char digit : number.toCharArray())

{

if(Character.getNumericValue(digit) != 0

&& Integer.parseInt(number) % Character.getNumericValue(digit) == 0)

{

result++;

}

System.out.println(result);

}

stdin.close();

}

JavaScript

function processData(input) {
    var inputs = input.split('\n');
    var tests = parseInt(inputs[0]);

    for(var i = 0; i < tests; i++) {
        for(var j = 1; j < inputs.length; j++) {
            var result = 0;
            var num = parseInt(inputs[j]);
            for(var k = 0; k < inputs[j].length; k++) {
                var c = parseInt(inputs[j][k]);
                if(c > 0 && num % c === 0) {
                    result++;
                }
            }
            console.log(result);
        }
        return;
    }
}

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 inputs = input.split('\n');

var tests = parseInt(inputs[0]);

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

for(var j = 1; j < inputs.length; j++) {

var result = 0;

var num = parseInt(inputs[j]);

for(var k = 0; k < inputs[j].length; k++) {

var c = parseInt(inputs[j][k]);

if(c > 0 && num % c === 0) {

result++;

}

console.log(result);

}

return;

}

process.stdin.resume();

process.stdin.setEncoding("ascii");

_input = "";

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

_input += input;

});

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

processData(_input);

});

Scala

object FindDigits extends App {
  var inputs = io.Source.stdin.getLines().toList.tail

  inputs.foreach {
    in =>
      println(in.toCharArray.count(d =>
        d.getNumericValue != 0 && in.toInt % d.getNumericValue == 0))
  }
}

object FindDigits extends App {

var inputs = io.Source.stdin.getLines().toList.tail

inputs.foreach {

in =>

println(in.toCharArray.count(d =>

d.getNumericValue != 0 && in.toInt % d.getNumericValue == 0))

}

Ruby

t = gets.to_i
t.times do
  num = gets.chomp.to_s
  result = 0
  num.split("").each do |c|
    c_num = c.to_i
    result +=1 if c_num > 0 && num.to_i % c_num == 0
  end
  puts result
end

t = gets.to_i

t.times do

num = gets.chomp.to_s

result = 0

num.split("").each do |c|

c_num = c.to_i

result +=1 if c_num > 0 && num.to_i % c_num == 0

end

puts result

end

Hackerrank – Find a Substring

Problem Statement A description of the problem can be found on Hackerrank. Solution For all lines cout all ocurrences of this regex pattern: \w+{substring}\w+ I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. Java

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FindSubstring {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int linesCount = Integer.parseInt(stdin.nextLine());
        String[] lines = new String[linesCount];
        for(int i = 0; i < linesCount; i++) {
            lines[i] = stdin.nextLine();
        }
        int substringCount = Integer.parseInt(stdin.nextLine());
        String[] substrings = new String[substringCount];
        for(int i = 0; i < substringCount; i++) {
            substrings[i] = stdin.nextLine();
        }
        for(int j = 0; j < substrings.length; j++) {
            int count = 0;
            String pattern = "\\w+" + substrings[j] + "\\w+";
            for(int i = 0; i < lines.length; i++) {
                String line = lines[i];
                Pattern p = Pattern.compile(pattern);
                Matcher m = p.matcher(line);
                while(m.find()) {
                    m.group();
                    count++;
                }
            }
            System.out.println(count);
        }
        stdin.close();
    }
}

import java.util.*;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class FindSubstring {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int linesCount = Integer.parseInt(stdin.nextLine());

String[] lines = new String[linesCount];

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

lines[i] = stdin.nextLine();

}

int substringCount = Integer.parseInt(stdin.nextLine());

String[] substrings = new String[substringCount];

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

substrings[i] = stdin.nextLine();

}

for(int j = 0; j < substrings.length; j++) {

int count = 0;

String pattern = "\\w+" + substrings[j] + "\\w+";

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

String line = lines[i];

Pattern p = Pattern.compile(pattern);

Matcher m = p.matcher(line);

while(m.find()) {

m.group();

count++;

}

System.out.println(count);

}

stdin.close();

}

JavaScript

'use strict';

const processData = input => {
    let inputLines = input.split('\n');
    let linesLength = parseInt(inputLines[0]);
    let substrings = inputLines.slice(linesLength + 2);
    for(let j = 0; j < substrings.length; j++) {
        let count = 0;
        let pattern = "\\w+" + substrings[j] + "\\w+";
        for(let i = 1; i <= linesLength; i++) {
            let line = inputLines[i];
            let match = line.match(new RegExp(pattern, "g"));
            count += match ? match.length : 0;
        }
        console.log(count);
    }
};

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

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

'use strict';

const processData = input => {

let inputLines = input.split('\n');

let linesLength = parseInt(inputLines[0]);

let substrings = inputLines.slice(linesLength + 2);

for(let j = 0; j < substrings.length; j++) {

let count = 0;

let pattern = "\\w+" + substrings[j] + "\\w+";

for(let i = 1; i <= linesLength; i++) {

let line = inputLines[i];

let match = line.match(new RegExp(pattern, "g"));

count += match ? match.length : 0;

}

console.log(count);

}

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

var _input = "";

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

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

Scala

import scala.io.Source

object FindSubstring extends App {
  val inputLines = Source.stdin.getLines().toList
  val linesLength = inputLines(0).toInt
  val lines = inputLines.slice(1, linesLength + 1)
  val substrings = inputLines.slice(linesLength + 2, inputLines.length)
  val counts = substrings.map(findSubstring(lines, _))
  println(counts.mkString("\n"))


  def findSubstring(lines: List[String], substring: String): Int = {
    lines.map(line => {
      val pattern = "\\w+" + substring + "\\w+"
      val matches = pattern.r.findAllMatchIn(line)
      matches.length
    }).sum
  }
}

import scala.io.Source

object FindSubstring extends App {

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

val linesLength = inputLines(0).toInt

val lines = inputLines.slice(1, linesLength + 1)

val substrings = inputLines.slice(linesLength + 2, inputLines.length)

val counts = substrings.map(findSubstring(lines, _))

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

def findSubstring(lines: List[String], substring: String): Int = {

lines.map(line => {

val pattern = "\\w+" + substring + "\\w+"

val matches = pattern.r.findAllMatchIn(line)

matches.length

}).sum

}

Ruby

lines_count = gets.chomp.to_i
words = []
lines_count.times do
  line = gets.chomp
  w = line.split
  w.each { |a| words << a}
end

pattern_count = gets.chomp.to_i
pattern_count.times do
  input = gets.chomp
  pattern = "[a-z_]+#{input}[a-z_]+"
  result = 0
  words.each do |word|
    if word =~ /\w+#{input}\w+/
      result += 1 
    end
  end
  puts result
end

lines_count = gets.chomp.to_i

words = []

lines_count.times do

line = gets.chomp

w = line.split

w.each { |a| words << a}

end

pattern_count = gets.chomp.to_i

pattern_count.times do

input = gets.chomp

pattern = "[a-z_]+#{input}[a-z_]+"

result = 0

words.each do |word|

if word =~ /\w+#{input}\w+/

result += 1

end

puts result

end

Hackerrank – Filling Jars

Problem Statement A description of the problem can be found on Hackerrank. Solution sum = (b – a + 1) * no_candies for each operations. Average and floor the sum. I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. 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

Problem Statement A description of the problem can be found on Hackerrank. Solution Use the equation for Fibonacci numbers in problem statement: Fibonacci(n) = 0 , n = 1 Fibonacci(n) = 1 , n = 2 Fibonacci(n) = Fibonacci(n-1) + Fibonacci(n-2) , n > 2 I created solution in: Scala All solutions are also available […]

Hackerrank – Even Tree

Problem Statement A description of the problem can be found on Hackerrank. Solution Make a map of a node vs. the nnumber of nodes connected to it. Iterate over the map. If for the ith node, the number of nodes connected is even, then iterate over the nodes list connected to this node. Now for […]

Hackerrank – Equations

Problem Statement A description of the problem can be found on Hackerrank. Solution Make prime number factorization of N!. For help click here or here. I created solution in: Java JavaScript Ruby Scala All solutions are also available on my GitHub. 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

}

Pavol Pidanič

I can count to 1023 with 10 fingers

Month: January 2016

Hackerrank – Flowers

Hackerrank – Flipping Bits

Hackerrank – Find Point

Hackerrank – Find Hackerrank

Hackerrank – Find Digits

Hackerrank – Find a Substring

Hackerrank – Filling Jars

Hackerrank – Fibonacci Numbers

Hackerrank – Even Tree

Hackerrank – Equations