Archives javascript - Page 9 of 12

Hackerrank – Handshake

Problem Statement A description of the problem can be found on Hackerrank. Solution I created solution in: Java JavaScript Ruby Scala All solutions are also available on my GitHub. Java

import java.util.*;

public class Handshake {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int tests = stdin.nextInt();
        for(int i = 0; i < tests; i++) {
            long handshakes = 0;
            int directors = stdin.nextInt();
            for(int j = 0; j < directors; j++) {
                handshakes += j;
            }
            System.out.println(handshakes);
        }
        stdin.close();
    }
}

import java.util.*;

public class Handshake {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int tests = stdin.nextInt();

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

long handshakes = 0;

int directors = stdin.nextInt();

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

handshakes += j;

}

System.out.println(handshakes);

}

stdin.close();

}

JavaScript

'use strict';

const processData = input => {
    let directors = input.split('\n').map(i => parseInt(i))
    for(let i = 1; i < directors.length; i++) {
        let handshakes = 0;
        for(let j = 0; j < directors[i]; j++) {
            handshakes += j;
        }
        console.log(handshakes);
    }
};

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 directors = input.split('\n').map(i => parseInt(i))

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

let handshakes = 0;

for(let j = 0; j < directors[i]; j++) {

handshakes += j;

}

console.log(handshakes);

}

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

var _input = "";

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

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

Ruby

gets.chomp.to_i.times do
  directors = gets.chomp.to_i
  result = 0
  (directors - 1).downto 0 do |handshakes|
    result += handshakes
  end
  puts result
end

gets.chomp.to_i.times do

directors = gets.chomp.to_i

result = 0

(directors - 1).downto 0 do |handshakes|

result += handshakes

end

puts result

end

Scala

import scala.io.Source

object Handshake extends App {
  val lines = Source.stdin.getLines()
  val directors = lines.drop(1).map(_.toInt)
  val handshakes = directors.map(Range(0, _).toList.sum)
  println(handshakes.mkString("\n"))
}

import scala.io.Source

object Handshake extends App {

val lines = Source.stdin.getLines()

val directors = lines.drop(1).map(_.toInt)

val handshakes = directors.map(Range(0, _).toList.sum)

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

}

Problem Statement A description of the problem can be found on Hackerrank. Solution Calculate chocolate pieces as: I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. Java

import java.util.*;

public class HalloweenParty {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int tests = stdin.nextInt();
        for(int i = 0; i < tests; i++) {
            long k = stdin.nextLong();
            long horizontal = k / 2;
            long vertical = k - horizontal;
            System.out.println(vertical * horizontal);
        }
        stdin.close();
    }
}

import java.util.*;

public class HalloweenParty {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

int tests = stdin.nextInt();

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

long k = stdin.nextLong();

long horizontal = k / 2;

long vertical = k - horizontal;

System.out.println(vertical * horizontal);

}

stdin.close();

}

JavaScript

'use strict';

const processData = input => {
    let lines = input.split("\n");
    let slices = lines.map(i => parseInt(i));
    const pieces = k => {
        let horizontal = parseInt(k / 2);
        let vertical = k - horizontal;
        return vertical * horizontal;
    };
    for(let i = 1; i < slices.length; i++) {
        console.log(pieces(slices[i]));
    }
};

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 slices = lines.map(i => parseInt(i));

const pieces = k => {

let horizontal = parseInt(k / 2);

let vertical = k - horizontal;

return vertical * horizontal;

};

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

console.log(pieces(slices[i]));

}

};

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 HalloweenParty extends App {
  val lines = Source.stdin.getLines()
  val slices = lines.drop(1).map(_.toLong)
  val result = slices.map(pieces)
  println(result.mkString("\n"))

  def pieces(k: Long): Long = {
    val horizontal = k / 2
    val vertical = k - horizontal
    vertical * horizontal
  }
}

import scala.io.Source

object HalloweenParty extends App {

val lines = Source.stdin.getLines()

val slices = lines.drop(1).map(_.toLong)

val result = slices.map(pieces)

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

def pieces(k: Long): Long = {

val horizontal = k / 2

val vertical = k - horizontal

vertical * horizontal

}

Ruby

test_cases = gets.chomp.to_i
test_cases.times do |test|
  slices = gets.chomp.to_i
  horizontal_slices = slices / 2
  vertical_slices = slices - horizontal_slices
  puts vertical_slices * horizontal_slices
end

test_cases = gets.chomp.to_i

test_cases.times do |test|

slices = gets.chomp.to_i

horizontal_slices = slices / 2

vertical_slices = slices - horizontal_slices

puts vertical_slices * horizontal_slices

end

Hackerrank – HackerRank Tweets

Problem Statement A description of the problem can be found on Hackerrank. Solution Check if every line in lowercase matches this regex pattern: .*hackerrank.* I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. Java

import java.util.*;

public class HackerrankTweets {

    public static void main(String[] args) {
        Scanner stdin = new Scanner(System.in);
        int tests = Integer.parseInt(stdin.nextLine());
        int count = 0;
        for(int i = 0; i < tests; i++) {
            if(stdin.nextLine().toLowerCase().matches(".*hackerrank.*")) {
                count++;
            }
        }
        System.out.println(count);
        stdin.close();
    }
}

import java.util.*;

public class HackerrankTweets {

public static void main(String[] args) {

Scanner stdin = new Scanner(System.in);

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

int count = 0;

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

if(stdin.nextLine().toLowerCase().matches(".*hackerrank.*")) {

count++;

}

System.out.println(count);

stdin.close();

}

JavaScript

'use strict';

const processData = input => {
    let lines = input.split('\n').slice(1);
    let matches = lines.filter(line => line.toLowerCase().match(/.*hackerrank.*/));
    console.log(matches.length);
};

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').slice(1);

let matches = lines.filter(line => line.toLowerCase().match(/.*hackerrank.*/));

console.log(matches.length);

};

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 HackerrankTweets extends App {
  val lines = Source.stdin.getLines().drop(1)
  val matchingLines = lines.count(_.toLowerCase.matches(".*hackerrank.*"))
  println(matchingLines)
}

import scala.io.Source

object HackerrankTweets extends App {

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

val matchingLines = lines.count(_.toLowerCase.matches(".*hackerrank.*"))

println(matchingLines)

}

Ruby

tests = gets.chomp.to_i
result = 0
tests.times do
  words = gets.chomp.split
  words.each do |word|
    result += 1 if word.downcase =~ /.*hackerrank.*/
  end
end

puts result

tests = gets.chomp.to_i

result = 0

tests.times do

words = gets.chomp.split

words.each do |word|

result += 1 if word.downcase =~ /.*hackerrank.*/

end

puts result

Hackerrank – Gemstones

Problem Statement A description of the problem can be found on Hackerrank. Solution Do intersect of all characters of strings comming as the input. I created solution in: Java JavaScript Ruby Scala All solutions are also available on my GitHub. Java

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class GemStones
{
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        int rocks = scanner.nextInt();

        char[] first = scanner.next().toCharArray();

        Set<Character> result = new HashSet<>();
        for (char c : first)
        {
            result.add(c);
        }

        for (int i = 1; i < rocks; i++)
        {
            char[] composition = scanner.next().toCharArray();
            Set<Character> set = new HashSet<>();
            for (char d : result)
            {
                for (int j = 0; j < composition.length; j++)
                {
                    if(d == composition[j])
                    {
                        set.add(composition[j]);
                    }
                }
            }
            result = set;
        }
        System.out.println(result.size());
        scanner.close();
    }
}

import java.util.HashSet;

import java.util.Scanner;

import java.util.Set;

public class GemStones

{

public static void main(String[] args)

{

Scanner scanner = new Scanner(System.in);

int rocks = scanner.nextInt();

char[] first = scanner.next().toCharArray();

Set<Character> result = new HashSet<>();

for (char c : first)

{

result.add(c);

}

for (int i = 1; i < rocks; i++)

{

char[] composition = scanner.next().toCharArray();

Set<Character> set = new HashSet<>();

for (char d : result)

{

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

{

if(d == composition[j])

{

set.add(composition[j]);

}

result = set;

}

System.out.println(result.size());

scanner.close();

}

JavaScript

function processData(input) {
    var lines = input.split('\n');
    var first = lines[1].split('');
    for(var i = 2; i < lines.length; i++) {
        first = intersect(first, lines[i].split(''));
    }
    console.log(first.length)
}

function intersect(arr1, arr2) {
    var unique1 = arr1.distinct();
    var unique2 = arr2.distinct();
    return unique1.distinct().filter(function(s) {
        return unique2.distinct().indexOf(s) !== -1
    });
}

Array.prototype.distinct = function() {
    var hash = {};
    var a = [];
    for(var i = 0; i < this.length; i++) {
        if(hash.hasOwnProperty(this[i])) {
            continue;
        }
        hash[this[i]] = true;
        a.push(this[i]);
    }
    return a;
};

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 first = lines[1].split('');

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

first = intersect(first, lines[i].split(''));

}

console.log(first.length)

}

function intersect(arr1, arr2) {

var unique1 = arr1.distinct();

var unique2 = arr2.distinct();

return unique1.distinct().filter(function(s) {

return unique2.distinct().indexOf(s) !== -1

});

}

Array.prototype.distinct = function() {

var hash = {};

var a = [];

for(var i = 0; i < this.length; i++) {

if(hash.hasOwnProperty(this[i])) {

continue;

}

hash[this[i]] = true;

a.push(this[i]);

}

return a;

};

process.stdin.resume();

process.stdin.setEncoding("ascii");

_input = "";

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

_input += input;

});

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

processData(_input);

});

Ruby

string_count = gets.to_i
first = gets.chars.uniq
(string_count - 1).times do
  s = gets.chars.uniq
  first = first & s
end
puts first.length

string_count = gets.to_i

first = gets.chars.uniq

(string_count - 1).times do

s = gets.chars.uniq

first = first & s

end

puts first.length

Scala

import scala.io.Source

object Gemstones extends App {
  val strings = Source.stdin.getLines().drop(1).toList

  val first = strings(0)
  val gemstones = strings.drop(1).foldLeft(first)(_ intersect _)
  println(gemstones.size)
}

import scala.io.Source

object Gemstones extends App {

val strings = Source.stdin.getLines().drop(1).toList

val first = strings(0)

val gemstones = strings.drop(1).foldLeft(first)(_ intersect _)

println(gemstones.size)

}

Hackerrank – Game of Thrones – I

Problem Statement A description of the problem can be found on Hackerrank. Solution Palindrome is when: if the length of a string is even, then each character needs to be even times in the string if the length of a string is odd, then there is only one character, which count in the string is […]

Hackerrank – Funny String

Problem Statement A description of the problem can be found on Hackerrank. Solution For index i in string s check if all differences are equals: I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. Java

import java.util.Scanner;

public class FunnyString 
{

    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++)
        {
            String s = stdin.nextLine();
            if(isFunny(s))
            {
                System.out.println("Funny");
            }
            else
            {
                System.out.println("Not Funny");
            }
            
        }
        stdin.close();
    }
    
    private static boolean isFunny(String s)
    {
        for(int j = 0; j < s.length() - 1; j++)
        {
            if(Math.abs(Character.codePointAt(s, j + 1) - Character.codePointAt(s, j)) !=
                    Math.abs(Character.codePointAt(s, s.length() - j - 2) - Character.codePointAt(s, s.length() - j - 1)))
            {
                return false;
            }
        }
        return true;
    }
}

import java.util.Scanner;

public class FunnyString

{

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++)

{

String s = stdin.nextLine();

if(isFunny(s))

{

System.out.println("Funny");

}

else

{

System.out.println("Not Funny");

}

stdin.close();

}

private static boolean isFunny(String s)

{

for(int j = 0; j < s.length() - 1; j++)

{

if(Math.abs(Character.codePointAt(s, j + 1) - Character.codePointAt(s, j)) !=

Math.abs(Character.codePointAt(s, s.length() - j - 2) - Character.codePointAt(s, s.length() - j - 1)))

{

return false;

}

return true;

}

JavaScript

function processData(input) {
    var lines = input.split('\n');
    for(var i = 1; i < lines.length; i++) {
        if(isFunny(lines[i])) {
            console.log("Funny");
        } else {
            console.log("Not Funny");
        }
    }
}

function isFunny(s) {
    for(var j = 0; j < s.length - 1; j++) {
        if(Math.abs(s.charCodeAt(j + 1) - s.charCodeAt(j)) !==
            Math.abs(s.charCodeAt(s.length - j - 2) - s.charCodeAt(s.length - j - 1))) {
            return false;
        }
    }
    return true;
}

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

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

if(isFunny(lines[i])) {

console.log("Funny");

} else {

console.log("Not Funny");

}

function isFunny(s) {

for(var j = 0; j < s.length - 1; j++) {

if(Math.abs(s.charCodeAt(j + 1) - s.charCodeAt(j)) !==

Math.abs(s.charCodeAt(s.length - j - 2) - s.charCodeAt(s.length - j - 1))) {

return false;

}

return true;

}

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 FunnyString extends App {
  val lines = Source.stdin.getLines().drop(1)
  val funnies = lines.map(funny).map(toText)
  println(funnies.mkString("\n"))

  def funny(s: String): Boolean = {
    val l = s.length
    s.indices.take(l - 1).forall(i =>
      (s.charAt(i) - s.charAt(i + 1)).abs == (s.charAt(l - i - 2) - s.charAt(l - i - 1)).abs)
  }

  def toText(b: Boolean): String = {
    if(b) "Funny" else "Not Funny"
  }
}

import scala.io.Source

object FunnyString extends App {

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

val funnies = lines.map(funny).map(toText)

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

def funny(s: String): Boolean = {

val l = s.length

s.indices.take(l - 1).forall(i =>

(s.charAt(i) - s.charAt(i + 1)).abs == (s.charAt(l - i - 2) - s.charAt(l - i - 1)).abs)

}

def toText(b: Boolean): String = {

if(b) "Funny" else "Not Funny"

}

Ruby

def funny?(s)
  for i in 0...s.length() - 1
    return false if((s[i].ord - s[i + 1].ord).abs != (s[s.length() - i - 2].ord - s[s.length() - i - 1].ord).abs)
  end
  return true
end

tests = gets.to_i
tests.times do
  s = gets.to_s.strip
  if funny?(s)
    puts "Funny"
  else
    puts "Not Funny"
  end
end

def funny?(s)

for i in 0...s.length() - 1

return false if((s[i].ord - s[i + 1].ord).abs != (s[s.length() - i - 2].ord - s[s.length() - i - 1].ord).abs)

end

return true

end

tests = gets.to_i

tests.times do

s = gets.to_s.strip

if funny?(s)

puts "Funny"

else

puts "Not Funny"

end

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

Pavol Pidanič

I can count to 1023 with 10 fingers

Tag: javascript

Hackerrank – Handshake

Hackerrank – Halloween Party

Hackerrank – HackerRank Tweets

Hackerrank – Gemstones

Hackerrank – Game of Thrones – I

Hackerrank – Funny String

Hackerrank – Flowers

Hackerrank – Flipping Bits

Hackerrank – Find Point

Hackerrank – Find Hackerrank