Archives scala - Page 11 of 15

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

}

Hackerrank – Detecting Valid Latitude and Longitude Pairs

Problem Statement A description of the problem can be found on Hackerrank. Solution My regex for validating longitude and latitude pairs: $[+-]?((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]+)?))))$ All solutions are also available on my GitHub.

Hackerrank – Detect HTML Tags

Problem Statement A description of the problem can be found on Hackerrank. Solution Parse all tags by regex pattern

Hackerrank – Detect HTML Attributes

Problem Statement A description of the problem can be found on Hackerrank. Solution Parse all tags with attributes. Then parse only tags and attributes. Group attributes by tag name. Sort grouped tags and accordingly attributes. I created solution in: Java Scala All solutions are also available on my GitHub. Java

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DetectHtmlAttributes
{
    private static final String REGEX = "<[a-z0-9]+(\\s+[a-z]+=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\\(\\),#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\'])*(\\s+/)?>";

    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        Pattern regex = Pattern.compile(REGEX);

        int tests = Integer.parseInt(scanner.nextLine());
        List<String> tagsWithAttributes = new ArrayList<>();
        for(int i = 0; i < tests; i++)
        {
            String line = scanner.nextLine();

            Matcher matcher = regex.matcher(line);

            while(matcher.find())
            {
                tagsWithAttributes.add(matcher.group());
            }
        }

        Map<String, Set<String>> map = new TreeMap<>();

        for(String tagAtt : tagsWithAttributes)
        {
            Pattern tagPattern = Pattern.compile("<[a-z0-9]+");
            Matcher tagMatcher = tagPattern.matcher(tagAtt);
            String tag = null;
            Set<String> attributes = new TreeSet<>();
            if(tagMatcher.find())
            {
                tag = tagMatcher.group().replace("<", "");
            }

            Pattern attPattern = Pattern
                    .compile("[a-z]+=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\\(\\),#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\']");
            Matcher attMatcher = attPattern.matcher(tagAtt);
            while(attMatcher.find())
            {
                attributes
                        .add(attMatcher
                                .group()
                                .trim()
                                .replaceAll(
                                        "=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\\(\\),#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\']",
                                        ""));
            }
            Set<String> mapSet = map.get(tag);
            if(mapSet != null && !mapSet.isEmpty())
            {
                mapSet.addAll(attributes);
                map.put(tag, mapSet);
            }
            else
            {
                map.put(tag, attributes);
            }
        }

        StringBuilder sb = new StringBuilder();
        for(String tag : map.keySet())
        {
            sb.append(tag);
            sb.append(":");
            for(String attribute : map.get(tag))
            {
                sb.append(attribute);
                sb.append(",");
            }
            if(!map.get(tag).isEmpty())
            {
                sb.deleteCharAt(sb.length() - 1);
            }
            System.out.println(sb);
            sb.delete(0, sb.length());
        }
        scanner.close();
    }
}

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.Scanner;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class DetectHtmlAttributes

{

private static final String REGEX = "<[a-z0-9]+(\\s+[a-z]+=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\$\$,#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\'])*(\\s+/)?>";

public static void main(String[] args)

{

Scanner scanner = new Scanner(System.in);

Pattern regex = Pattern.compile(REGEX);

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

List<String> tagsWithAttributes = new ArrayList<>();

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

{

String line = scanner.nextLine();

Matcher matcher = regex.matcher(line);

while(matcher.find())

{

tagsWithAttributes.add(matcher.group());

}

Map<String, Set<String>> map = new TreeMap<>();

for(String tagAtt : tagsWithAttributes)

{

Pattern tagPattern = Pattern.compile("<[a-z0-9]+");

Matcher tagMatcher = tagPattern.matcher(tagAtt);

String tag = null;

Set<String> attributes = new TreeSet<>();

if(tagMatcher.find())

{

tag = tagMatcher.group().replace("<", "");

}

Pattern attPattern = Pattern

.compile("[a-z]+=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\$\$,#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\']");

Matcher attMatcher = attPattern.matcher(tagAtt);

while(attMatcher.find())

{

attributes

.add(attMatcher

.group()

.trim()

.replaceAll(

"=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\$\$,#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\']",

""));

}

Set<String> mapSet = map.get(tag);

if(mapSet != null && !mapSet.isEmpty())

{

mapSet.addAll(attributes);

map.put(tag, mapSet);

}

else

{

map.put(tag, attributes);

}

StringBuilder sb = new StringBuilder();

for(String tag : map.keySet())

{

sb.append(tag);

sb.append(":");

for(String attribute : map.get(tag))

{

sb.append(attribute);

sb.append(",");

}

if(!map.get(tag).isEmpty())

{

sb.deleteCharAt(sb.length() - 1);

}

System.out.println(sb);

sb.delete(0, sb.length());

}

scanner.close();

}

Scala

import scala.io.Source
import scala.collection.mutable.Map

object DetectHtmlAttributes extends App {

  private[this] val TAG_WITH_ATTRIBUTE_REGEX =
    "<[a-z0-9]+(\\s+[a-z]+=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\\(\\),#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\'])*(\\s+/)?>".r
  private[this] val TAG_NAME_REGEX = "<[a-z0-9]+".r
  private[this] val ATTRIBUTE_REGEX =
    "[a-z]+=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\\(\\),#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\']".r
  private[this] val ATTRIBUTE_VALUE_PATTERN = "=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\\(\\),#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\']"

  val lines = Source.stdin.getLines().drop(1).toList
  val tagsWithAttributes = lines.map(findTagsWithAttributes).flatten
  val tagNames = tagsWithAttributes.map(parseTagName).flatten
  val attributes = tagsWithAttributes.map(parseAttributes)
  val tagGroups = groupAttributesByTags()
  createOutput()

  def findTagsWithAttributes(line: String): List[String] = {
    TAG_WITH_ATTRIBUTE_REGEX.findAllMatchIn(line).map(_.toString()).toList
  }

  def parseTagName(tag: String): List[String] = {
    TAG_NAME_REGEX.findAllMatchIn(tag).map(_.toString).map(_.replace("<", "")).toList
  }

  def parseAttributes(tag: String): List[String] = {
    ATTRIBUTE_REGEX.findAllMatchIn(tag).map(_.toString)
      .map(_.replaceAll(ATTRIBUTE_VALUE_PATTERN, "")).toList
  }

  def groupAttributesByTags(): Map[String, List[String]] = {
    val tagGroups: Map[String, List[String]] = Map.empty
    tagNames.indices.foreach(i => {
      val tag = tagNames(i)
      val attributeList = attributes(i)
      val actualAttributes = tagGroups.getOrElse(tag, Nil)
      tagGroups.put(tag, attributeList:::actualAttributes)
    })
    tagGroups
  }

  def createOutput(): Unit = {
    val sortedKeys = tagGroups.keys.toList.sorted
    sortedKeys.foreach(tag => {
      val sortedAttributes = tagGroups.get(tag).get.distinct.sorted
      println(tag + ":" + sortedAttributes.mkString(","))
    })
  }
}

import scala.io.Source

import scala.collection.mutable.Map

object DetectHtmlAttributes extends App {

private[this] val TAG_WITH_ATTRIBUTE_REGEX =

"<[a-z0-9]+(\\s+[a-z]+=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\$\$,#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\'])*(\\s+/)?>".r

private[this] val TAG_NAME_REGEX = "<[a-z0-9]+".r

private[this] val ATTRIBUTE_REGEX =

"[a-z]+=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\$\$,#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\']".r

private[this] val ATTRIBUTE_VALUE_PATTERN = "=[\\\"\\'][a-zA-Z\\[\\]\\-\\/\\\\:\\.\\s_\\?!\\d;\$\$,#@\\{\\}=%\\&\\|\\+\\*]*[\\\"\\']"

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

val tagsWithAttributes = lines.map(findTagsWithAttributes).flatten

val tagNames = tagsWithAttributes.map(parseTagName).flatten

val attributes = tagsWithAttributes.map(parseAttributes)

val tagGroups = groupAttributesByTags()

createOutput()

def findTagsWithAttributes(line: String): List[String] = {

TAG_WITH_ATTRIBUTE_REGEX.findAllMatchIn(line).map(_.toString()).toList

}

def parseTagName(tag: String): List[String] = {

TAG_NAME_REGEX.findAllMatchIn(tag).map(_.toString).map(_.replace("<", "")).toList

}

def parseAttributes(tag: String): List[String] = {

ATTRIBUTE_REGEX.findAllMatchIn(tag).map(_.toString)

.map(_.replaceAll(ATTRIBUTE_VALUE_PATTERN, "")).toList

}

def groupAttributesByTags(): Map[String, List[String]] = {

val tagGroups: Map[String, List[String]] = Map.empty

tagNames.indices.foreach(i => {

val tag = tagNames(i)

val attributeList = attributes(i)

val actualAttributes = tagGroups.getOrElse(tag, Nil)

tagGroups.put(tag, attributeList:::actualAttributes)

})

tagGroups

}

def createOutput(): Unit = {

val sortedKeys = tagGroups.keys.toList.sorted

sortedKeys.foreach(tag => {

val sortedAttributes = tagGroups.get(tag).get.distinct.sorted

println(tag + ":" + sortedAttributes.mkString(","))

})

}

Pavol Pidanič

I can count to 1023 with 10 fingers

Tag: scala

Hackerrank – Find Hackerrank

Hackerrank – Find Digits

Hackerrank – Find a Substring

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