Archives regex - Page 3 of 3

Hackerrank – IP Address Validation

Problem Statement A description of the problem can be found on Hackerrank. Solution IP4 regex: \b(((2[0-5][0-5])|(1[0-9][0-9])|(\b[1-9][0-9]\b)|(\b\d\b))\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\b[1-9][0-9]\b)|(\b\d\b))\b IP6 regex: ([a-f0-9]{1,4}:){7}\b[0-9a-f]{1,4}\b I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. Java

import java.util.*;

public class IPAddressValidation {

    private static final String IP6_PATTERN = "([a-f0-9]{1,4}:){7}\\b[0-9a-f]{1,4}\\b";
    private static final String IP4_PATTERN =
            "\\b(((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\b";

    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++) {
            System.out.println(ipValidation(stdin.nextLine()));
        }
        stdin.close();
    }

    private static String ipValidation(String address) {
        if(address.matches(IP6_PATTERN))
            return "IPv6";
        else if(address.matches(IP4_PATTERN))
            return "IPv4";
        else
            return "Neither";
    }
}

import java.util.*;

public class IPAddressValidation {

private static final String IP6_PATTERN = "([a-f0-9]{1,4}:){7}\\b[0-9a-f]{1,4}\\b";

private static final String IP4_PATTERN =

"\\b(((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\b";

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

System.out.println(ipValidation(stdin.nextLine()));

}

stdin.close();

}

private static String ipValidation(String address) {

if(address.matches(IP6_PATTERN))

return "IPv6";

else if(address.matches(IP4_PATTERN))

return "IPv4";

else

return "Neither";

}

JavaScript

'use strict';

const IP6_PATTERN = "([a-f0-9]{1,4}:){7}\\b[0-9a-f]{1,4}\\b";
const IP4_PATTERN =
    "\\b(((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\b";

const processData = input => {
    let lines = input.split('\n').slice(1);
    let ipValidation = address => {
        if(address.match(new RegExp(IP4_PATTERN))) {
            return "IPv4";
        } else if(address.match(new RegExp(IP6_PATTERN))) {
            return "IPv6";
        } else {
            return "Neither";
        }
    };
    let validations = lines.map(ipValidation);
    console.log(validations.join('\n'));
};

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 IP6_PATTERN = "([a-f0-9]{1,4}:){7}\\b[0-9a-f]{1,4}\\b";

const IP4_PATTERN =

"\\b(((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\b";

const processData = input => {

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

let ipValidation = address => {

if(address.match(new RegExp(IP4_PATTERN))) {

return "IPv4";

} else if(address.match(new RegExp(IP6_PATTERN))) {

return "IPv6";

} else {

return "Neither";

}

};

let validations = lines.map(ipValidation);

console.log(validations.join('\n'));

};

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 IPAddressValidation extends App {
  private[this] val IP6_PATTERN = "([a-f0-9]{1,4}:){7}\\b[0-9a-f]{1,4}\\b"
  private[this] val IP4_PATTERN =
    "\\b(((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\b"

  val lines = Source.stdin.getLines().drop(1)
  val validation = lines.map(ipValidation)
  println(validation.mkString("\n"))

  def ipValidation(address: String): String = {
    if(address.matches(IP6_PATTERN))
      "IPv6"
    else if(address.matches(IP4_PATTERN))
      "IPv4"
    else
      "Neither"
  }
}

import scala.io.Source

object IPAddressValidation extends App {

private[this] val IP6_PATTERN = "([a-f0-9]{1,4}:){7}\\b[0-9a-f]{1,4}\\b"

private[this] val IP4_PATTERN =

"\\b(((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\\b[1-9][0-9]\\b)|(\\b\\d\\b))\\b"

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

val validation = lines.map(ipValidation)

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

def ipValidation(address: String): String = {

if(address.matches(IP6_PATTERN))

"IPv6"

else if(address.matches(IP4_PATTERN))

"IPv4"

else

"Neither"

}

Ruby

tests = gets.chomp.to_i
tests.times do
  input = gets.chomp.to_s
  if input =~ /\b(((2[0-5][0-5])|(1[0-9][0-9])|(\b[1-9][0-9]\b)|(\b\d\b))\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\b[1-9][0-9]\b)|(\b\d\b))\b/
    puts "IPv4" 
  elsif input =~ /([a-f0-9]{1,4}:){7}\b[0-9a-f]{1,4}\b/
    puts "IPv6"
  else
    puts "Neither"
  end
end

tests = gets.chomp.to_i

tests.times do

input = gets.chomp.to_s

if input =~ /\b(((2[0-5][0-5])|(1[0-9][0-9])|(\b[1-9][0-9]\b)|(\b\d\b))\.){3}((2[0-5][0-5])|(1[0-9][0-9])|(\b[1-9][0-9]\b)|(\b\d\b))\b/

puts "IPv4"

elsif input =~ /([a-f0-9]{1,4}:){7}\b[0-9a-f]{1,4}\b/

puts "IPv6"

else

puts "Neither"

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 – 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 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 – 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(","))

})

}

Hackerrank – Alien Username

Problem Statement A description of the problem can be found on Hackerrank. Solution Regular Expression that validates input username: ^[_\.]\d+[a-zA-Z]*_?$ I created solution in: Java JavaScript Scala Ruby All solutions are also available on my GitHub. Java

import java.util.Scanner;

public class AlienUsername
{
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        int testCases = scanner.nextInt();
        for (int i = 0; i < testCases; i++)
        {
            String input = scanner.next();
            if(input.matches("[_\\.]\\d+[a-zA-Z]*_?"))
            {
                System.out.println("VALID");
            }
            else
            {
                System.out.println("INVALID");
            }
        }
        scanner.close();
    }
}

import java.util.Scanner;

public class AlienUsername

{

public static void main(String[] args)

{

Scanner scanner = new Scanner(System.in);

int testCases = scanner.nextInt();

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

{

String input = scanner.next();

if(input.matches("[_\\.]\\d+[a-zA-Z]*_?"))

{

System.out.println("VALID");

}

else

{

System.out.println("INVALID");

}

scanner.close();

}

JavaScript

function processData(input) {
    var lines = input.split("\n");
    for(var i = 1; i < lines.length; i++) {
        if(lines[i].match(/^[_\.]\d+[a-z]*_?$/ig)) {
            console.log("VALID");
        } else {
            console.log("INVALID");
        }
    }
}

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(lines[i].match(/^[_\.]\d+[a-z]*_?$/ig)) {

console.log("VALID");

} else {

console.log("INVALID");

}

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 AlienUsername extends App {
  val usernames = Source.stdin.getLines().drop(1)

  println(usernames.map(validateUsername).mkString("\n"))

  def validateUsername(name: String): String = {
    if (name.matches("[_\\.]\\d+[a-zA-Z]*_?"))
      return "VALID"
    else
      return "INVALID"
  }
}

import scala.io.Source

object AlienUsername extends App {

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

println(usernames.map(validateUsername).mkString("\n"))

def validateUsername(name: String): String = {

if (name.matches("[_\\.]\\d+[a-zA-Z]*_?"))

return "VALID"

else

return "INVALID"

}

Ruby

n = gets.to_i
n.times do
  name = gets.to_s.strip
  if /[_\.]\d+[a-zA-Z]*_?/ =~ name
    puts "VALID"
  else
    puts "INVALID"
  end
end

n = gets.to_i

n.times do

name = gets.to_s.strip

if /[_\.]\d+[a-zA-Z]*_?/ =~ name

puts "VALID"

else

puts "INVALID"

end

Pavol Pidanič

I can count to 1023 with 10 fingers

Tag: regex

Hackerrank – IP Address Validation

Hackerrank – HackerRank Tweets

Hackerrank – Find Hackerrank

Hackerrank – Find a Substring

Hackerrank – Detecting Valid Latitude and Longitude Pairs

Hackerrank – Detect HTML Tags

Hackerrank – Detect HTML Attributes

Hackerrank – Alien Username