w.kinaan
BAN USERpublic class Solution1 {
public static void main (String args[]) {
Solution1 s = new Solution1();
System.out.println(s.solve(-333));
}
public String solve(int number) {
if (number == 0)
return "0";
String results = "";
boolean negative = false;
if (number < 0){
results = "-";
negative = true;
}
if (negative)
number = number * (-1);
int remain = number % 10;
number = number / 10;
if (number != 0)
return results+""+solve(number)+remain;
return results+""+remain;
}
}
import java.util.*;
public class Solution {
public static void main (String args[]) {
Solution solution = new Solution();
solution.add(1, 2);
solution.add(1, 3);
solution.add(1, 1);
solution.add(2, 2);
solution.add(2, 5);
solution.add(2, 3);
solution.add(3, 7);
solution.add(3, 3);
solution.add(3, 1);
solution.solve();
}
private Map<Integer, Set<Integer>> hotels;
private PriorityQueue<Node> queue;
public Solution() {
this.hotels = new HashMap<>();
this.queue = new PriorityQueue<>();
}
public void add(int userId, int hotelId) {
if (this.hotels.containsKey(hotelId)) {
this.hotels.get(hotelId).add(userId);
}else{
Set<Integer>set = new HashSet<>();
set.add(userId);
this.hotels.put(hotelId, set);
}
}
public void solve() {
Iterator<Integer> iterator = hotels.keySet().iterator();
while(iterator.hasNext()) {
int hotelId = iterator.next();
int numberOfUsers = hotels.get(hotelId).size();
Node node = new Node(hotelId, numberOfUsers);
this.queue.add(node);
}
Node node = queue.poll();
System.out.println("Hotel "+node.hotelId +", has been visted by: "+node.numberOfUsers+" users");
}
private class Node implements Comparable<Node>{
int hotelId;
int numberOfUsers;
public Node (int hotelId, int numberOfUsers) {
this.hotelId = hotelId;
this.numberOfUsers = numberOfUsers;
}
@Override
public int compareTo(Node node) {
if (hotelId == node.hotelId)
return 0;
if (this.numberOfUsers < node.numberOfUsers)
return 1;
if (this.numberOfUsers > node.numberOfUsers)
return -1;
return 0;
}
}
}
import java.util.*;
public class Solution {
public static void main (String args[]) {
Solution solution = new Solution();
String string = "acacabcatghhellomvnsdb";
System.out.println(solution.find(string, "aca"));
System.out.println(solution.find(string, "cat"));
System.out.println(solution.find(string, "hello"));
System.out.println(solution.find(string, "world"));
System.out.println(solution.find(string, "a"));
}
public int find(String string, String word) {
if (string.length() == 0)
return 0;
if (word.length() == 0)
return 0;
if (word.length() > string.length())
return 0;
word = word.toLowerCase();
string = string.toLowerCase();
if (string.charAt(0) == word.charAt(0)) {
String potentialEqual = string.substring(0, word.length());
if (potentialEqual.equals(word)) {
return 1+find(string.substring(1), word);
}else{
return find(string.substring(1), word);
}
}else{
return find(string.substring(1), word);
}
}
}
import java.util.*;
public class Solution {
public static void main(String args[]) {
String[] words = new String[] {"abactor" ,"abaculus", "abacus", "Abaditeuuu"};
new Solution().solve(words);
}
private Map<Character, Integer> map;
public Solution() {
this.map = new HashMap<>();
}
private void add(String[] words) {
for (String word: words)
add(word);
}
private void add(String word) {
word = word.toLowerCase();
for (int i = 0 ;i < word.length() ; i++) {
Character c = new Character(word.charAt(i));
if (map.containsKey(c)) {
map.put(c, map.get(c) + 1);
}else{
map.put(c, 1);
}
}
}
public void solve(String[] words) {
add(words);
Set<Character> set = map.keySet();
Iterator<Character> iterator = set.iterator();
while(iterator.hasNext()) {
Character c = iterator.next();
int value = this.map.get(c);
queue.add(new Node(c.charValue(), value));
}
while(!queue.isEmpty()) {
Node node = queue.poll();
for(int i = 0 ;i < node.value;i++)
System.out.print("*");
System.out.println(node.c);
}
}
PriorityQueue<Node> queue = new PriorityQueue<>();
private class Node implements Comparable<Node>{
char c;
int value;
public Node(char c, int value) {
this.c = c;
this.value = value;
}
@Override
public int compareTo(Node node) {
if (this.c < node.c)
return -1;
if (this.c > node.c)
return 1;
return 0;
}
}
}
public class Wow {
public static void main (String args[]) {
System.out.println(new Wow().solve("Featuring stylish rooms and moornings for recreation"));
System.out.println(new Wow().solve("Featuring stylish rooms roma o ornings for recreation"));
}
public String solve(String string) {
if (string.length() <= 30)
return string;
return solve(string, 30);
}
private String solve(String string, int index) {
if (index < 1)
return "";
if (string.charAt(index-1) == ' ')
return string.substring(0, index);
return solve(string, --index);
}
}
import java.util.*;
public class Solution {
public static void main (String args[]) {
int [] array1 = new int[] {0, 1, 1, 2, 2, 5};
int [] array2 = new int[] {0, 1, 2, 2, 2, 6};
List<Integer> results = new Solution().solve(array1, array2);
for (Integer i : results){
System.out.print(i.intValue()+" ");
}
}
private Map<Integer, Integer> map;
public Solution(){
this.map = new HashMap<>();
}
private void add(int value) {
if (!this.map.containsKey(value)) {
this.map.put(value, 1);
}else{
this.map.put(value, this.map.get(value)+1);
}
}
public List<Integer> solve(int [] array1, int[] array2) {
for (int i : array1)
add(i);
List<Integer> results = new LinkedList<>();
for (int i : array2) {
if (map.containsKey(i)) {
if (map.get(i) > 1) {
results.add(i);
map.put(i, map.get(i)-1);
}else{
results.add(i);
map.remove(i);
}
}
}
return results;
}
}
import java.util.*;
public class Solution {
public static void main (String args[]) {
int [] array1 = new int[] {3,1, 4, 5, 19, 6};
int [] array2 = new int[] {14, 9, 22, 36, 8, 0, 64, 25};
List<Integer> list = new Solution().solve(array1, array2);
for (int i : list)
System.out.println(i);
}
private Node root;
public void add(int value) {
add(root, value);
}
private void add(Node node, int value) {
if (root == null) {
root = new Node(value);
}else{
if (node.value > value) {
if (node.left == null) {
node.left= new Node(value);
}else{
add(node.left , value);
}
}else{
if (node.right == null) {
node.right = new Node(value);
}else{
add(node.right, value);
}
}
}
}
private Node find(int value) {
return find(root, value);
}
private Node find(Node node, int value) {
if (node == null)
return null;
if (node.value == value)
return node;
if (node.value > value)
return find(node.left , value);
return find(node.right, value);
}
public List<Integer> solve(int [] array1, int [] array2) {
for (int i : array1) {
add(i);
}
List<Integer> list = new LinkedList<>();
for (int i : array2) {
int sqare = (int) Math.sqrt(i);
Node node = find(sqare);
if (node != null && (sqare * sqare == i)){
list.add(i);
}
}
return list;
}
}
class Node {
int value;
Node left, right;
public Node(int value) {
this.value = value;
this.left = null;
this.right= null;
}
}
public class Repeat {
public static void main (String args[]) {
System.out.println(new Repeat().compress("abababaabbbaaaaa"));
}
public String compress(String string) {
if (string.length() == 0)
return "";
return compress(string, string.charAt(0), 0);
}
private String compress(String string, char c, int count) {
if (string.length() == 0)
return c+""+count+"";
if (string.charAt(0) == c) {
return compress(string.substring(1), c, count + 1);
}else{
if (count == 0)
return c+""+compress(string.substring(1));
return c+""+count+compress(string);
}
}
}
import java.util.*;
public class Jib {
public static void main (String args[]) {
System.out.println(new Jib().add("{{(4[][])}}"));
}
private Stack<Character> stack;
public Jib() {
this.stack = new Stack<Character>();
}
public boolean add(String string) {
for (int i = 0 ;i < string.length() ;i++) {
if (okayToAdd(string.charAt(i))) {
stack.add(string.charAt(i));
}else {
return false;
}
}
Set<Character> set = new HashSet<>();
set.add(new Character('['));
set.add(new Character('{'));
set.add(new Character('('));
while(!stack.isEmpty()) {
if (set.contains(stack.pop()))
return false;
}
return true;
}
private boolean okayToAdd(char character) {
switch (character) {
case '}':
return poll('}');
case ')':
return poll(')');
case ']':
return poll(']');
default:
return true;
}
}
private boolean poll(char c) {
Set<Character> notAllowed = buildNotAllowed(c);
boolean found = false;
while(!stack.isEmpty() && !found) {
Character character = stack.pop();
if (notAllowed.contains(character))
return false;
if (character.charValue() == getOpeningParenthesis(c))
return true;
}
return true;
}
private Set<Character> buildNotAllowed(char c) {
Set<Character> set = new HashSet<>();
set.add(new Character('['));
set.add(new Character('{'));
set.add(new Character('('));
char op = getOpeningParenthesis(c);
Set<Character> results = new HashSet<>();
Iterator<Character> iterator = set.iterator();
while(iterator.hasNext()) {
Character character = iterator.next();
if (character.charValue() != op)
results.add(character);
}
return results;
}
private char getOpeningParenthesis(int c) {
switch (c) {
case '}':
return '{';
case ')':
return '(';
case ']':
return '[';
default:
return ' ';
}
}
}
import java.util.*;
public class Trie {
public static void main(String args[]) {
Trie trie = new Trie();
trie.add("William");
trie.add("williamRoma");
trie.add("williamRoma");
trie.add("williamRome");
System.out.println(trie.calculateCompleteWords());
Set<String> suggestions = trie.findSuggestions("Wi");
for (String word : suggestions) {
System.out.println(word);
}
}
TrieNode root;
public Trie() {
root = new TrieNode(new Character(' '));
}
public void add(String word) {
word = word.toLowerCase();
add(root, word);
}
public Set<String> findSuggestions(String word) {
word = word.toLowerCase();
TrieNode node = isPrefix(word);
if (node == null)
return new HashSet<>();
return findSuggestions(node, word);
}
private Set<String> findSuggestions(TrieNode node, String value) {
Set<String> results = new HashSet<>();
Iterator<Character> iterator = node.children.keySet().iterator();
while(iterator.hasNext()) {
Character character = iterator.next();
if (node.children.get(character).complete) {
results.add(value+character.charValue()+"");
}
results.addAll(findSuggestions(node.children.get(character), value+character.charValue()+""));
}
return results;
}
private TrieNode isPrefix(String word) {
return isPrefix(word, root);
}
private TrieNode isPrefix(String word, TrieNode node) {
if (word.length() == 0)
return null;
if (node == null)
return null;
char character = word.charAt(0);
if (node.children.containsKey(new Character(character))) {
if (word.length() == 1) {
return node.children.get(new Character(character));
}
return isPrefix(word.substring(1), node.children.get(new Character(character)));
}
return null;
}
private void add(TrieNode node, String word) {
if (word.length() == 0)
return;
char character = word.charAt(0);
if (node == null) {
node = new TrieNode(new Character(character));
if (word.length() > 1) {
add(node, word.substring(1));
} else {
node.complete = true;
}
} else {
if (node.children.containsKey(new Character(character))) {
if (word.length() > 1) {
add(node.children.get(new Character(character)),
word.substring(1));
} else {
node.children.get(new Character(character)).complete = true;
}
} else {
TrieNode trieNode = new TrieNode(new Character(character));
node.children.put(new Character(character), trieNode);
if (word.length() > 1) {
add(node.children.get(new Character(character)),
word.substring(1));
} else {
node.children.get(new Character(character)).complete = true;
}
}
}
}
public int calculateCompleteWords() {
return calculateCompleteWords(root);
}
private int calculateCompleteWords(TrieNode node) {
if (node == null)
return 0;
int count = 0;
if (node.complete == true) {
count = 1;
}
Iterator<Character> iterator = node.children.keySet().iterator();
while (iterator.hasNext()) {
Character charater = iterator.next();
count += calculateCompleteWords(node.children.get(new Character(
charater)));
}
return count;
}
}
class TrieNode {
Character character;
Map<Character, TrieNode> children;
boolean complete;
public TrieNode(Character character) {
this.character = character;
this.children = new HashMap<>();
}
}
public class Sol {
public static void main (String args[]) {
System.out.println(Arrays.toString(new Sol().find("williamwilliam", new String[] {"l", "iam"})));
}
public int[] find(String string, String[] words) {
int[] results = new int[words.length];
int i = 0;
for (String one: words) {
results[i] = find(string, 0, one, 0, false);
i++;
}
return results;
}
private int find(String string, int index, String word, int index2, boolean continu) {
if (continu) {
if (word.charAt(index2) == string.charAt(index)) {
if (index2 == word.length()-1) {
return 1;
}else{
return find(string, index+1, word, index2+1, true);
}
}else{
return 0;
}
}else{
char c = word.charAt(0);
int count = 0;
for (int i = index ;i< string.length();i++) {
if (string.charAt(i) == c) {
if (word.length() == 1)
count++;
else{
count+=find(string, i+1, word, 1, true);
}
}
}
return count;
}
}
}
- w.kinaan September 03, 2017