import java.util.Arrays; import java.util.Base64; import java.util.List; import java.util.Scanner; import java.util.concurrent.CopyOnWriteArrayList; import java.util.function.BiFunction; import java.util.function.Function; import java.util.function.Supplier; import java.util.function.UnaryOperator; import java.util.stream.Collectors; import static java.lang.System.out; /*** * The {@code FlamesRelationshipCalculator} will tell you the relationship between two person. * The flames calculator is based on quite a simple algorithm in which FLAMES stands for: * * ■ Friendship; * ■ Love; * ■ Affection; * ■ Marriage; * ■ Enemy; * ■ Siblings. * * You have to input two names for which you want the relationship. * Then you need to eliminate the letters that are common to both words, * no matter how many times they appear. * The next step is to count the letters that remained. * Then you use the number you obtained to count the letters from the word FLAMES. * If the number is greater than 6 you continue counting from the letter F once again. * The letter on which the number lands on reveals the relationship between the two persons. * * INPUT FORMAT. (PROVIDE TWO NAME IN SEPARATED LINES) * Nick * Priyanka * * * @author Pawan Maurya * @since September 26, 2020 */ public class FlamesRelationshipCalculator { private static Scanner scanner = new Scanner(System.in); public static void main(String[] args) { out.println('\u2764' + " The Flame Calculator! " + '\u2764'); // inputs names String name1 = scanner.nextLine(); String name2 = scanner.nextLine(); out.println(calculateRelationship.apply( remainingLetterCount.apply( removeSpace.apply(name1), removeSpace.apply(name2)), toCapitalize.apply(name1), toCapitalize.apply(name2))); scanner = null; // deallocate memory out.println(predefineTxt.get()); } private static int count; /** * The {@code Node} class will represents the node for FLAMES * this class create a circular doubly linked list. */ static class Node { char data; Node next; Node prev; /** * @param data for adding node data */ Node(char data) { // count will be increase by 1. if the element will be // add in a doubly linked list ++count; // data will be initialize here this.data = data; } } private Node start = null; private Node head = null; /** * @return the current total number of node. */ private static int getCount() { return count; } /** * @param c helps to store data in the node. */ private void add(char c) { // create a node element Node newNode = new Node(c); // if the doubly linked list will be empty if (start == null) { start = newNode; start.next = start.prev = newNode; head = start; } else { // if list are not empty newNode.next = head; newNode.prev = start; start.next = newNode; start = newNode; head.prev = newNode; } } /** * This anonymous function helps map character in the List. */ private static Function> stringToCharArrayList = name -> name.chars().mapToObj(c -> (char) c).collect(Collectors.toList()); /** * This anonymous function helps to remove common character in both name and return the * remaining letter count. * Firstly it will use {@link #stringToCharArrayList} anonymous function to map the character array into list. */ private static BiFunction remainingLetterCount = (name1, name2) -> { // Here I converted the list to CopyOnWriteArrayList to avoid ConcurrentModificationException final CopyOnWriteArrayList firstNameCharactersList = new CopyOnWriteArrayList<>(stringToCharArrayList.apply(name1)); final CopyOnWriteArrayList secondNameCharacterList = new CopyOnWriteArrayList<>(stringToCharArrayList.apply(name2)); firstNameCharactersList.stream().filter(secondNameCharacterList::contains).forEach(c -> { // Here if filtering the common letter while (firstNameCharactersList.contains(c)) firstNameCharactersList.remove(c); while (secondNameCharacterList.contains(c)) secondNameCharacterList.remove(c); } ); firstNameCharactersList.addAll(secondNameCharacterList); // it will return the reaming letter count from two to string. return firstNameCharactersList.size(); }; private static UnaryOperator decode = str -> new String(Base64.getDecoder().decode(str)); private static TriFunction displayRelationship = (letter, name1, name2) -> { switch (letter) { case 'F': return String.format("\n%s is your Friend \n\n%s", name2, decode.apply("ICAsZDg4Yi5kODhiLAogIDg4ODg4ODg4ODg4CiAgYFk4ODg4ODg4WScKICAgIGBZODg4WScgICAgRnJpZW5kIEZvcmV2ZXIKICAgICAgYFknCiA=")); case 'L': return String.format("\n\n %c %s loves %s %c \n\n %s", '\u2764', name1, name2, '\u2764', decode.apply("ICAgICAqKioqKiogICAgICAgKioqKioqCiAgICoqKioqKioqKiogICAqKioqKioqKioqCiAqKioqKioqKioqKioqICoqKioqKioqKioqKioKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoqKioqKioqKioqKioqKioqKioqKioqKioqKgogICAqKioqKioqKioqKioqKioqKioqKioqKgogICAgICoqKioqKioqKioqKioqKioqKioKICAgICAgICoqKioqKioqKioqKioqKgogICAgICAgICAqKioqKioqKioqKgogICAgICAgICAgICoqKioqKioKICAgICAgICAgICAgICoqKgogICAgICAgICAgICAgICon")); case 'A': return String.format("%s is attracted towards you. \n\n %s", name2, decode.apply("ICAgICAgICAgICAgLDs7Ozs7OzssCiAgICAgICAgICAgOzs7Ozs7Ozs7OzssCiAgICAgICAgICA7Ozs7OydfX19fXzsnCiAgICAgICAgICA7OzsoLykpKSl8KChcCiAgICAgICAgICBfOzsoKCgoKCh8KSkpKQogICAgICAgICAvIHxfXFxcXFxcXFxcXFxcCiAgICAuLS1+KCAgXCB+KSkpKSkpKSkpKSkpCiAgIC8gICAgIFwgIGBcLSgoKCgoKCgoKCgoXFwKICAgfCAgICB8IGBcICAgKSB8XCAgICAgICAvfCkKICAgIHwgICAgfCAgYC4gXy8gIFxfX19fXy8gfAogICAgIHwgICAgLCBgXH4gICAgICAgICAgICAvCiAgICAgIHwgICAgXCAgXCAgICAgICAgICAgLwogICAgIHwgYC4gICBgXHwgICAgICAgICAgLwogICAgIHwgICB+LSAgIGBcICAgICAgICAvCiAgICAgIFxfX19ffi5fL34gLV8sICAgKFwKICAgICAgIHwtLS0tLXxcICAgXCAgICAnOzsKICAgICAgfCAgICAgIHwgOjs7OycgICAgIFwKICAgICB8ICAvICAgIHwgICAgICAgICAgICB8CiAgICAgfCAgICAgICB8ICAgICAgICAgICAgfCAKICAgICAgfCAgICAgIGAuICAgICAgICAgICAv")); case 'M': return String.format("%s you will get Married to %s \n\n %s", name1, name2, decode.apply("ICAgICAgICAgICAgICAgICAgICAtLS4KICAgICAgICAgIEBAQCAgICAgICAgICAgLyAgKSkKICAgICAgICAgKCggfSAgICAgICAgICAgN18gLwogICAgICAgICBgYCkgICAgICAgICAgICAgLyBcCiAgICAgICAgYGAoIFwgICAgICAgICAgIHw8fCB8CiAgICAgICBgYGBcYC5cX18gICAgIF9fL3wvfCB8CiAgICAgIGBgYGAgKXwtLS1+b18pfF9fX3wgfCB8CiAgICAgfn5+fn4vIFxgICAgICAgICAgIHwgfF98CiAgICAgICAgIC8gJyBcYCAgICAgICAgIHxfXz4pCiAgICAgICAgLyAgJyAgXGAgICAgICAgIHx8IHwKICAgICAgIC8gICAnICAgIGAgICAgICAgfFwgXAogICAgICAvICAgXyFfXy4tLl9gICAgICB8IFwgXAogICAgIC9fLi0nICAoIHwgICAgICAgICB8IHxcIFwKICAgICAgICAvICAgIGB8ICAgICAgICAgfF98IFxfXAogICAgICAgfGBfICAgfGBfICAgICAgX18nXylfXy4tJw==")); case 'E': return String.format("'%s is your sworn Enemy \n\n%s", name2, decode.apply("ICAgICAgICAgICAgICBfXy4uLi4uLi5fXwogICAgICAgICAgICAuLTo6Ojo6Ojo6Ojo6OjotLgogICAgICAgICAgLjo6OicnJzo6Ojo6OjonJyc6OjouCiAgICAgICAgLjo6OicgICAgIGA6OjonICAgICBgOjo6LiAKICAgLidcICA6OicgICBeXl4gIGA6JyAgXl5eICAgJzo6ICAvYC4KICA6ICAgXCA6OiAgIF8uX18gICAgICAgX18uXyAgIDo6IC8gICA7CiA6ICAgICBcYDogLicgX19fXCAgICAgL19fXyBgLiA6Jy8gICAgIDsgCjogICAgICAgL1wgICAoX3xfKVwgICAvKF98XykgICAvXCAgICAgICA7CjogICAgICAvIC5cICAgX18uJyApICggYC5fXyAgIC8uIFwgICAgICA7CjogICAgICBcICggICAgICAgIHsgICB9ICAgICAgICApIC8gICAgICA7IAogOiAgICAgIGAtKCAgICAgLiAgXiJeICAuICAgICApLScgICAgICA7CiAgYC4gICAgICAgXCAgLic8YC0uXy4tJz4nLiAgLyAgICAgICAuJwogICAgYC4gICAgICBcICAgIFw7YC4nOy8gICAgLyAgICAgIC4nCiAgICAgICBgLl8gICAgYC0uXyAgICAgICBfLi0nICAgIF8uJwogICAgICAgLidgLS5fXyAuJ2AtLl8uLSdgLiBfXy4tJ2AuCiAgICAgLicgICAgICAgYC4gICAgICAgICAuJyAgICAgICBgLgogICAuJyAgICAgICAgICAgYC0uICAgLi0nICAgICAgICAgICBgLic=")); case 'S': return String.format("'%s is your Sibling \n\n%s", name2, decode.apply("ICAgICAgICAgICAgLi0iJyctLiAgXwogICAgICAgICAgLicgICAgICAgYCggXAogICAgICAgIEAvICAgICAgICAgICAgJykgICAsLS0sX18sLSIKICAgICAgICAvICAgICAgICAvICAgICAgXCAvICAgICAvICAgXy8KICAgICAgX198ICAgICAgICAgICAsICAgfC8gICAgICAgICAvCiAgICAufiAgYFwgICAvIFwgLCAgfCAgIC8KICAufiAgICAgIGBcICAgIGAgIC8gIF8vICAgXy8KLn4gICAgICAgICAgYFwgIH5+YF9fLyAgICAvCn4gICAgICAgICAgICAgYC0tJy8KICAgICAgICAgICAgIC8gICAvICAgIC8KICAgICAgICAgICAgLyAgLycgICAgLyc=")); default: return "Please try again later."; } }; private static TriFunction calculateRelationship = (remainingLetterCount, name1, name2) -> { FlamesRelationshipCalculator flamesCal = new FlamesRelationshipCalculator(); flamesCal.add('F'); flamesCal.add('L'); flamesCal.add('A'); flamesCal.add('M'); flamesCal.add('E'); flamesCal.add('S'); while (FlamesRelationshipCalculator.getCount() > 1) { int i = 1; while (i < remainingLetterCount) { i++; flamesCal.head = flamesCal.head.next; } Node head = flamesCal.head; Node prev = head.prev; Node next = head.next; prev.next = next; next.prev = prev; flamesCal.head = next; --count; } return displayRelationship.apply(flamesCal.head.data, name1, name2); }; interface TriFunction { R apply(X x, Y y, Z z); } private static Function removeSpace = s -> s.replaceAll(" ", "").toLowerCase(); private static Supplier predefineTxt = () -> "\nTag your friend with whom you calculated FLames.\nDon't forgot to comment and likes." + "\n\nHow It's work ?." + " \nThe flames calculator is based on quite a simple algorithm in which FLAMES stands for:" + " * ■ Friendship;\n" + " * ■ Love;\n" + " * ■ Affection;\n" + " * ■ Marriage;\n" + " * ■ Enemy;\n" + " * ■ Siblings.\n" + " *\n" + " * You have to input two names for which you want the relationship .\n" + " * Then you need to eliminate the letters that are common to both words,\n" + " * no matter how many times they appear.\n" + " * The next step is to count the letters that remained.\n" + " * Then you use the number you obtained to count the letters from the word FLAMES.\n" + " * If the number is greater than 6 you continue counting from the letter F once again.\n" + " * The letter on which the number lands on reveals the relationship between the two persons." + "\n" + "\n\n" + String.format("%30s", "Created By : Pawan Maurya"); private static UnaryOperator toCapitalize = str -> Arrays.stream(str.split("[\\s+]")) .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1)).collect(Collectors.joining(" ")); }

❤️ Flames Love Calcutor ❤️