Este repositório está dedicado a armazenar minhas observações, anotações e soluções referentes aos desafios de Java apresentados na plataforma Hackerrank.
Todos os desafios já foram resolvidos, no entanto, o processo de adaptar os textos do Hackerrank para um arquivo .md é trabalhoso e, por isso, nem todos possuem um documento contendo enunciado e explicação. Se você tiver interesse em simplesmente acessar a resolução de um desafio, basta seguir as instruções do gif abaixo.
Bem vindo ao Java! — Welcome to Java Entrada Padrão e Saída Padrão I — Java Stdin/Stdout (Standard Input/Output) I Entrada Padrão e Saída Padrão II — Java Stdin/Stdout (Standard Input/Output) II Se e Senão — Java If-Else Formatação de Saída — Java Output Formatting Laços de Repetição I — Java Loops I Laços de Repetição II — Java Loops II Tipos de Dados — Java Datatypes
Final de Arquivo — Java End-of-File
Bloco Estático de Inicialização — Java Static Initializer Block
Conversão de Tipos — Java Int to String
Data e Tempo — Java Date and Time
Formatação Monetária — Java Currency Formatter
Texto em Java — Java Strings Introduction
Partes de um Texto — Java Substring
Comparações entre Partes de um Texto — Java Substring Comparisons
Texto ao Contrário — Java String Reverse
Anagramas — Java Anagrams
Tokens — Java String Tokens
Padrão para Checagem de Sintaxe — Java Pattern Syntax Checker
Expressões Regulares — Java Regex
Expressões Regulares para Palavras Duplicadas — Java Regex 2 (Duplicate Words)
Expressões Regulares para Validação de Nomes de Usuário — Java Valid Username Regular Expression
Extrator de Conteúdo de Tags — Java Tag Content Extractor
Números Grandes — BigNumber
Teste de Primalidade — Java Primality Test
Tipo de Dado Abstrato para Inteiros Grandes — Java BigInteger
Tipo de Dado Abstrato para Decimais Grandes — Java BigDecimal
Conjuntos de Dados Unidimensionais I — Java 1D Array
Conjuntos de Dados Unidimensionais II — Java 1D Array (Part 2)
Conjuntos de Dados Bidimensionais — Java 2D Array
Subconjuntos — Java Subarray
Listas I — Java List
Listas II — Java ArrayList
Mapeamento — Java Map
Pilha — Java Stack
Hashset — Java HashSet
Tipos Genéricos — Java Generics
Interface para Comparação — Java Comparator
Ordenação Simples — Java Sort
Fila com Duplo Final (Fila Duplamente Terminada) — Java Deque
Tipo Abstrato de Dado para Conjuntos de Bits — Java BitSet
Fila com Prioridade — Java Priority Queue
Programação Orientada a Objetos
Herança I — Java Inheritance I
Herança II — Java Inheritance II
Classes Abstratas — Java Abstract Class
Interfaces — Java Interface
Polimorfismo de Sobrescrita I — Java Method Overriding
Polimorfismo de Sobrescrita II — Java Method Overriding 2 (Super Keyword)
Verificando Tipos usando Instanceof — Java Instanceof Keyword
Iterator — Java Iterator
Tratamento de Exceção I — Java Exception Handling (throws and throw new)
Tratamento de Exceção II — Java Exception Handling (try-catch-finally)
Múltiplos Argumentos em Função — Java Varargs (Simple Addition)
API para Reflexão I — Java Reflection API (Attributes)
API para Reflexão II — Java Reflection API II (Class and Methods - Can You Access)
Checagem de Primos utilizando Múltiplos Argumentos em Função — Java Prime Checker (Varargs and Static Import)
Padrões de Projeto I — Java Factory Pattern
Padrões de Projeto II — Java Singleton Pattern
Padrões de Projeto III — Java Visitor Pattern
Anotações em Java — Java Annotations
Retorno de Tipos Covariantes — Java Covariant Return Types
Expressões Anônimas — Java Lambda Expressions
MD5 — Java MD5
SHA-256 — Java SHA-256
Mais ou Menos — Java Plus Minus
Mínimo e Máximo — Java Mini-Max Sum
Conversão de Tempo — Java Time Conversion
Mediana e Collections.sort() — Java Mock Test
Inteiro Solitário — Java Lonely Integer
Diferença entre as Diagonais — Java Diagonal Difference
Ordenação por Contagem I — Java Counting Sort
Sequência Zig Zag — Java Zig Zag Sequence
Destruidores de Torres — Java Tower Breakers
Cifra de Cesar — Java Caesar Cipher
Desafio das Matrizes — Java Grid Challenge
Soma Recursiva de Dígitos — Java Recursive Digit Sum
Caos de Ano Novo — Java New Year Chaos
Mesclar Duas Listas Simplesmente Encadeadas Ordenadas — Java Merge Two Sorted Linked Lists
Fila Usando Duas Pilhas — Java Queue Using Two Stacks
Abre-Fecha Balanceado — Java Balanced Brackets
Editor de Texto Simples — Java Simple Text Editor
Blocos de Lego (Tetranacci) — Java Lego Blocks
Jesse e os Cookies — Java Jesse and Cookies
Árvores: Percorrimento Pré-Ordem — Tree: Preorder Traversal
Árvores: Decodificando Huffman — Tree: Huffman Decoding
Conjunto Sem Prefixo — Java No Prefix Set
Formatação de Saída - Java Output Formatting
import java .util .Scanner ;
public class OutputFormatting {
public static void main (String [] args ) {
Scanner sc = new Scanner (System .in );
System .out .println ("================================" );
for (int i = 0 ; i < 3 ; i ++) {
String s1 = sc .next ();
int x = sc .nextInt ();
System .out .printf ("%-15s%03d%n" , s1 , x );
}
sc .close ();
System .out .println ("================================" );
}
}
Laços de Repetição I - Java Loops I
import java .io .*;
import java .math .*;
import java .security .*;
import java .text .*;
import java .util .*;
import java .util .concurrent .*;
import java .util .regex .*;
public class Loops {
public static void main (String [] args ) throws IOException {
BufferedReader bufferedReader = new BufferedReader (new InputStreamReader (System .in ));
int n = Integer .parseInt (bufferedReader .readLine ().trim ());
for (int i = 1 ; i <= 10 ; i ++) System .out .println (n + " x " + i + " = " + n *i );
bufferedReader .close ();
}
}
Laços de Repetição II - Java Loops II
import java .util .*;
import java .io .*;
public class Loops2 {
public static void main (String []argh ) {
Scanner in = new Scanner (System .in );
int t = in .nextInt ();
for (int i = 0 ; i < t ; i ++){
int a = in .nextInt ();
int b = in .nextInt ();
int n = in .nextInt ();
int c = 1 ;
int x = 0 ;
for (int j = 0 ; j < n ; j ++, c *= 2 ) {
if (j == 0 ) {
x = a + c * b ;
}else {
x += c * b ;
}
System .out .print (x );
if (j < n ) {
System .out .print (" " );
}
}
System .out .println ();
}
in .close ();
}
}
Tipos de Dados - Java Datatypes
import java .util .*;
import java .io .*;
public class Datatypes {
public static void main (String []argh ) {
Scanner sc = new Scanner (System .in );
int t = sc .nextInt ();
for (int i = 0 ; i < t ; i ++) {
try {
long x =sc .nextLong ();
System .out .println (x + " can be fitted in:" );
if (x >= -128 && x <= 127 ) System .out .println ("* byte" );
if (x >= -32768 && x <= 32767 ) System .out .println ("* short" );
if (x >= -2147483648L && x <= 2147483647L ) System .out .println ("* int" );
System .out .println ("* long" );
}catch (Exception e ) {
System .out .println (sc .next () + " can't be fitted anywhere." );
}
}
sc .close ();
}
}
Final de Arquivo - Java End-of-File
import java .io .*;
import java .util .*;
import java .text .*;
import java .math .*;
import java .util .regex .*;
public class EndOfFile {
public static void main (String [] args ) {
Scanner sc = new Scanner (System .in );
int i = 1 ;
while (sc .hasNext ()) {
System .out .println (i + " " + sc .nextLine ());
i ++;
}
sc .close ();
}
}
Bloco Estático de Inicialização - Java Static Initializer Block
import java .io .*;
import java .util .*;
import java .text .*;
import java .math .*;
import java .util .regex .*;
public class StaticInitializerBlock {
public static boolean flag ;
public static int B ;
public static int H ;
static {
Scanner sc = new Scanner (System .in );
B = sc .nextInt ();
H = sc .nextInt ();
sc .close ();
try {
if (B <= 0 || H <= 0 ) {
flag = false ;
throw new Exception ("Breadth and height must be positive" );
}else {
flag = true ;
}
}catch (Exception e ) {
System .out .println (e );
}
}
public static void main (String [] args ) {
if (flag ) {
int area = B * H ;
System .out .print (area );
}
}
}
Conversão de Tipos - Java Int to String
import java .util .*;
import java .security .*;
public class IntToString {
public static void main (String [] args ) {
DoNotTerminate .forbidExit ();
try {
Scanner in = new Scanner (System .in );
int n = in .nextInt ();
in .close ();
//String s=???; Complete this line below
String s = String .format ("%d" , n );
if (n == Integer .parseInt (s )) {
System .out .println ("Good job" );
}else {
System .out .println ("Wrong answer." );
}
}catch (DoNotTerminate .ExitTrappedException e ) {
System .out .println ("Unsuccessful Termination!!" );
}
}
}
//The following class will prevent you from terminating the code using exit(0)!
class DoNotTerminate {
public static class ExitTrappedException extends SecurityException {
private static final long serialVersionUID = 1 ;
}
public static void forbidExit () {
final SecurityManager securityManager = new SecurityManager () {
@ Override
public void checkPermission (Permission permission ) {
if (permission .getName ().contains ("exitVM" )) {
throw new ExitTrappedException ();
}
}
};
System .setSecurityManager (securityManager );
}
}
Data e Tempo - Java Date and Time
import java .io .*;
import java .math .*;
import java .security .*;
import java .text .*;
import java .util .*;
import java .util .concurrent .*;
import java .util .function .*;
import java .util .regex .*;
import java .util .stream .*;
import static java .util .stream .Collectors .joining ;
import static java .util .stream .Collectors .toList ;
class Result {
public static String findDay (int month , int day , int year ) {
Calendar c = Calendar .getInstance ();
c .set (year , (month - 1 ), day );
String t = c .getDisplayName (Calendar .DAY_OF_WEEK , Calendar .LONG , Locale .US );
return t .toUpperCase ();
}
}
public class DateAndTime {
public static void main (String [] args ) throws IOException {
BufferedReader bufferedReader = new BufferedReader (new InputStreamReader (System .in ));
BufferedWriter bufferedWriter = new BufferedWriter (new FileWriter (System .getenv ("OUTPUT_PATH" )));
String [] firstMultipleInput = bufferedReader .readLine ().replaceAll ("\\ s+$" , "" ).split (" " );
int month = Integer .parseInt (firstMultipleInput [0 ]);
int day = Integer .parseInt (firstMultipleInput [1 ]);
int year = Integer .parseInt (firstMultipleInput [2 ]);
String res = Result .findDay (month , day , year );
bufferedWriter .write (res );
bufferedWriter .newLine ();
bufferedReader .close ();
bufferedWriter .close ();
}
}
Formatação Monetária - Java Currency Formatter
import java .util .*;
import java .text .*;
public class CurrencyFormatter {
public static void main (String [] args ) {
Scanner sc = new Scanner (System .in );
double payment = sc .nextDouble ();
sc .close ();
System .out .println ("US: " + NumberFormat .getCurrencyInstance (Locale .US ).format (payment ));
System .out .println ("India: " + NumberFormat .getCurrencyInstance (new Locale ("en" , "IN" )).format (payment ));
System .out .println ("China: " + NumberFormat .getCurrencyInstance (Locale .CHINA ).format (payment ));
System .out .println ("France: " + NumberFormat .getCurrencyInstance (Locale .FRANCE ).format (payment ));
}
}
Texto em Java - Java Strings Introduction
import java .io .*;
import java .util .*;
public class StringsIntroduction {
public static void main (String [] args ) {
Scanner sc =new Scanner (System .in );
String a = sc .next ();
String b = sc .next ();
String greaterThan = a .compareTo (b ) > 0 ? "Yes" : "No" ;
System .out .println (a .length () + b .length ());
System .out .println (greaterThan );
System .out .println (a .substring (0 ,1 ).toUpperCase () + a .substring (1 ,a .length ()) + " " + b .substring (0 ,1 ).toUpperCase () + b .substring (1 ,b .length ()));
}
}
Partes de um Texto - Java Substring
import java .io .*;
import java .util .*;
import java .text .*;
import java .math .*;
import java .util .regex .*;
public class Substring {
public static void main (String [] args ) {
Scanner in = new Scanner (System .in );
String s = in .next ();
int start = in .nextInt ();
int end = in .nextInt ();
System .out .println (s .substring (start ,end ));
}
}
Comparações entre Partes de um Texto - Java Substring Comparisons
import java .io .*;
import java .util .*;
public class SubstringComparisons {
public static void main (String [] args ) {
Scanner sc = new Scanner (System .in );
String s = sc .next ();
int k = sc .nextInt ();
String [] out = getSmallestAndLargest (s ,k );
System .out .println (out [0 ]);
System .out .println (out [1 ]);
}
public static String [] getSmallestAndLargest (String s , int k ) {
String smallest = s .substring (0 ,k );
String biggest = smallest ;
for (int i = 1 ; i < s .length () - (k - 1 ); i ++) {
String toCheck = s .substring (i ,i +k );
if (toCheck .compareTo (smallest ) < 0 ) {
smallest = toCheck ;
}
if (toCheck .compareTo (biggest ) > 0 ) {
biggest = toCheck ;
}
}
return new String [] {smallest , biggest };
}
}
Texto ao Contrário - Java String Reverse
import java .io .*;
import java .util .*;
public class StringReverse {
public static void main (String [] args ) {
Scanner sc = new Scanner (System .in );
String res = isPalindrome (sc .next ()) ? "Yes" : "No" ;
System .out .println (res );
}
public static boolean isPalindrome (String s ) {
for (int i = 0 , j = s .length () - 1 ; i < (s .length () / 2 ); i ++, j --) {
if (s .charAt (i ) != s .charAt (j )) {
return false ;
}
}
return true ;
}
}
Anagramas - Java Anagrams
import java .io .*;
import java .util .*;
public class Anagrams {
public static boolean isAnagram (String a , String b ) {
if (a .length () != b .length ()) {
return false ;
}
int [] c = new int [26 ];
for (int i = 0 ; i < a .length (); i ++) {
c [((Character .toLowerCase (a .charAt (i )) - 96 ) % 27 ) - 1 ]++;
}
for (int j = 0 ; j < b .length (); j ++) {
if (c [((Character .toLowerCase (b .charAt (j )) - 96 ) % 27 ) - 1 ] > 0 ) {
c [((Character .toLowerCase (b .charAt (j )) - 96 ) % 27 ) - 1 ]--;
}else {
return false ;
}
}
return true ;
}
public static void main (String [] args ) {
Scanner sc = new Scanner (System .in );
String a = sc .next ();
String b = sc .next ();
String res = isAnagram (a ,b ) ? "Anagrams" : "Not Anagrams" ;
System .out .println (res );
}
}
Tokens - Java String Tokens
import java .io .*;
import java .util .*;
public class StringTokens {
public static void main (String [] args ) {
Scanner sc = new Scanner (System .in );
String in = sc .nextLine ();
in = in .trim ();
if (in .length () == 0 || in .equals ("" )) {
System .out .println (0 );
}else {
String [] out = in .split ("[^a-zA-Z]+" );
System .out .println (out .length );
for (String s : out ) {
System .out .println (s );
}
}
}
}
Padrão para Checagem de Sintaxe - Java Pattern Syntax Checker
import java .io .*;
import java .util .*;
import java .util .regex .*;
public class PatternSyntaxChecker {
public static void main (String [] args ) {
Scanner in = new Scanner (System .in );
int testCases = Integer .parseInt (in .nextLine ());
while (testCases > 0 ) {
String pattern = in .nextLine ();
try {
Pattern pat = Pattern .compile (pattern );
System .out .println ("Valid" );
}catch (PatternSyntaxException pse ) {
System .out .println ("Invalid" );
}
testCases --;
}
}
}
Expressões Regulares - Java Regex I
import java .io .*;
import java .util .*;
import java .util .regex .*;
class MyRegex {
public static final Pattern PATTERN = Pattern .compile ("(0[0-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]|[0-9][0-9]|[0-9])\\ .(0[0-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]|[0-9][0-9]|[0-9])\\ .(0[0-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]|[0-9][0-9]|[0-9])\\ .(0[0-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]|[0-9][0-9]|[0-9])" );
}
public class Regex1 {
public static void main (String [] args ) {
Scanner sc = new Scanner (System .in );
while (sc .hasNextLine ()) {
String actual = sc .nextLine ();
Matcher m = MyRegex .PATTERN .matcher (actual );
System .out .println (m .matches ());
}
}
}
Expressões Regulares para Palavras Duplicadas - Java Regex II
import java .util .Scanner ;
import java .util .regex .Matcher ;
import java .util .regex .Pattern ;
public class Regex2 {
public static void main (String [] args ) {
String regex = "\\ b(\\ w+)(?:\\ W+\\ 1\\ b)+" ;
Pattern p = Pattern .compile (regex , Pattern .CASE_INSENSITIVE );
Scanner in = new Scanner (System .in );
int numSentences = Integer .parseInt (in .nextLine ());
while (numSentences -- > 0 ) {
String input = in .nextLine ();
Matcher m = p .matcher (input );
while (m .find ()) {
input = input .replaceAll (m .group (), m .group (1 ));
}
System .out .println (input );
}
in .close ();
}
}
Expressões Regulares para Validação de Nomes de Usuário - Java Valid Username Regular Expression
import java .util .Scanner ;
class UsernameValidator {
public static final String regularExpression = "[A-Za-z][A-Za-z0-9_]{7,29}" ;
}
public class ValidUsernameRegularExpression {
private static final Scanner scan = new Scanner (System .in );
public static void main (String [] args ) {
int n = Integer .parseInt (scan .nextLine ());
while (n -- != 0 ) {
String userName = scan .nextLine ();
if (userName .matches (UsernameValidator .regularExpression )) {
System .out .println ("Valid" );
}else {
System .out .println ("Invalid" );
}
}
}
}
Extrator de Conteúdo de Tags - Java Tag Content Extractor
import java .io .*;
import java .util .*;
public class TagContentExtractor {
public static void main (String [] args ) {
Scanner in = new Scanner (System .in );
ArrayList <String > valids = new ArrayList <>();
int n , i , count_valid_per_line ;
boolean read_tag , read_end_tag , read_content ;
String input , tag , content , end_tag ;
n = in .nextInt ();
in .nextLine ();
read_tag = false ;
read_end_tag = false ;
read_content = false ;
while (--n >= 0 ) {
input = in .nextLine ();
count_valid_per_line = 0 ;
tag = "" ;
content = "" ;
end_tag = "" ;
for (i = 0 ; i < input .length (); i ++) {
if (input .charAt (i ) == '<' ) {
if (i + 1 < input .length () && input .charAt (i + 1 ) == '/' ) {
end_tag = "" ;
read_end_tag = true ;
read_tag = false ;
read_content = false ;
}else {
tag = "" ;
content = "" ;
read_end_tag = false ;
read_tag = true ;
read_content = false ;
}
}else {
if (input .charAt (i ) == '>' ) {
if (read_tag ) {
read_tag = false ;
read_content = true ;
}
if (read_end_tag ) {
read_tag = false ;
read_end_tag = false ;
read_content = false ;
if (tag .equals (end_tag ) && !tag .equals ("" )) {
//System.out.println("VALID");
//System.out.println("TAG: "+tag);
//System.out.println("CONTENT: "+content);
//System.out.println("END_TAG: "+end_tag);
if (!content .equals ("" )) {
valids .add (content );
count_valid_per_line ++;
}
}
tag = "" ;
end_tag = "" ;
}
}else {
if (read_tag ) {
tag += input .charAt (i );
}
if (read_end_tag ) {
if (input .charAt (i ) != '/' ) {
end_tag += input .charAt (i );
}
}
if (read_content ) {
content += input .charAt (i );
}
}
}
}
//System.out.println();
if (count_valid_per_line == 0 ) {
valids .add ("None" );
}
}
for (String s : valids ) {
System .out .println (s );
}
}
}
