Foo🍫

Author: thesaravanakumar

Level 1/Braille Translation/readme.txt

@@ -0,0 +1,45 @@
+Braille Translation
+===================
+
+Because Commander Lambda is an equal-opportunity despot, she has several visually-impaired minions. But she never bothered to follow intergalactic standards for workplace accommodations, so those minions have a hard time navigating her space station. You figure printing out Braille signs will help them, and - since you'll be promoting efficiency at the same time - increase your chances of a promotion. 
+
+Braille is a writing system used to read by touch instead of by sight. Each character is composed of 6 dots in a 2x3 grid, where each dot can either be a bump or be flat (no bump). You plan to translate the signs around the space station to Braille so that the minions under Commander Lambda's command can feel the bumps on the signs and "read" the text with their touch. The special printer which can print the bumps onto the signs expects the dots in the following order:
+1 4
+2 5
+3 6
+
+So given the plain text word "code", you get the Braille dots:
+
+11 10 11 10
+00 01 01 01
+00 10 00 00
+
+where 1 represents a bump and 0 represents no bump.  Put together, "code" becomes the output string "100100101010100110100010".
+
+Write a function answer(plaintext) that takes a string parameter and returns a string of 1's and 0's representing the bumps and absence of bumps in the input string. Your function should be able to encode the 26 lowercase letters, handle capital letters by adding a Braille capitalization mark before that character, and use a blank character (000000) for spaces. All signs on the space station are less than fifty characters long and use only letters and spaces.
+
+Languages
+=========
+
+To provide a Python solution, edit solution.py
+To provide a Java solution, edit solution.java
+
+Test cases
+==========
+
+Inputs:
+    (string) plaintext = "code"
+Output:
+    (string) "100100101010100110100010"
+
+Inputs:
+    (string) plaintext = "Braille"
+Output:
+    (string) "000001110000111010100000010100111000111000100010"
+
+Inputs:
+    (string) plaintext = "The quick brown fox jumps over the lazy dog"
+Output:
+    (string) "000001011110110010100010000000111110101001010100100100101000000000110000111010101010010111101110000000110100101010101101000000010110101001101100111100011100000000101010111001100010111010000000011110110010100010000000111000100000101011101111000000100110101010110110"
+
+Use verify [file] to test your solution and see how it does. When you are finished editing your code, use submit [file] to submit your answer. If your solution passes the test cases, it will be removed from your home folder.

Level 1/Braille Translation/solution.py

@@ -0,0 +1,81 @@
+def answer(plaintext):
+    # Find the braille letter equale english letter
+    switcher = {
+        "a": "100000",
+        "b": "110000",
+        "c": "100100",
+        "d": "100110",
+        "e": "100010",
+        "f": "110100",
+        "g": "110110",
+        "h": "110010",
+        "i": "010100",
+        "j": "010110",
+        "k": "101000",
+        "l": "111000",
+        "m": "101100",
+        "n": "101110",
+        "o": "101010",
+        "p": "111100",
+        "q": "111110",
+        "r": "111010",
+        "s": "011100",
+        "t": "011110",
+        "u": "101001",
+        "v": "111001",
+        "w": "010111",
+        "x": "101101",
+        "y": "101111",
+        "z": "101011",
+        "1": "100000",
+        "2": "110000",
+        "3": "100100",
+        "4": "100110",
+        "5": "100010",
+        "6": "110100",
+        "7": "110110",
+        "8": "110010",
+        "9": "010100",
+        "0": "010110",
+        ".": "010011",
+        "-": "010010",
+        ",": "010000",
+        "!": "011010",
+        "?": "011001",
+        ":": "010010",
+        "(": "011011",
+        ")": "011011",
+        "/": "001100",
+        "#": "001111",
+        ";": "011000",
+        "[": "000001011011",
+        "]": "011011001000",
+        "capital": "000001",
+        "_": "001001001001001001",
+        "'": "001000",
+        "+": "011010",
+        "*": "011001",
+        ">": "101010",
+        "<": "010101",
+        "@": "001110",
+        "%": "010110001011",
+        " ": "000000"
+    }
+    result = ""
+    lastCharIsDigit = False
+    for l in plaintext:
+        if l.isdigit():
+            if not lastCharIsDigit:
+                lastCharIsDigit = True
+                result += switcher.get("#", "")
+        else:
+            lastCharIsDigit = False
+            if l.isupper():
+                result += switcher.get("capital", "")
+
+        result += switcher.get(l.lower(), "")
+    return result
+
+
+# sample
+print(answer("Braille"))

Level 1/I Love Lance & Janice/Solution.java

@@ -0,0 +1,26 @@
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class Solution {
+
+    public static String solution(String encryptedText) {
+        return encryptedText.chars()
+            // Decodes the current character.
+            .map(c -> (c >= 'a' && c <= 'z') ? ('a' + 'z' - c) : c)
+            // Converts the mapped character from an integer.
+            .mapToObj(c -> (char) c)
+            .map(Objects::toString)
+            .collect(Collectors.joining());
+    }
+
+    public static void main(String... args) {
+        String inputOne = "wrw blf hvv ozhg mrtsg’h vkrhlwv?";
+        String inputTwo = "Yvzs! I xzm’g yvorvev Lzmxv olhg srh qly zg gsv xlolmb!!";
+        String outputOne = "did you see last night’s episode?";
+        String outputTwo = "Yeah! I can’t believe Lance lost his job at the colony!!";
+
+        assert solution(inputOne).equals(outputOne);
+        assert solution(inputTwo).equals(outputTwo);
+    }
+
+}

Level 1/I Love Lance & Janice/readme.txt

@@ -0,0 +1,57 @@
+## I Love Lance & Janice
+
+Time to solve: 48 hours.
+
+### Description
+
+You’ve caught two of your fellow minions passing coded notes back and forth – while they’re on duty, no less! Worse, you’re pretty sure it’s not job-related – they’re both huge fans of the space soap opera “Lance & Janice”. You know how much Commander Lambda hates waste, so if you can prove that these minions are wasting her time passing non-job-related notes, it’ll put you that much closer to a promotion.
+
+Fortunately for you, the minions aren’t exactly advanced cryptographers. In their code, every lowercase letter [a..z] is replaced with the corresponding one in [z..a], while every other character (including uppercase letters and punctuation) is left untouched. That is, ‘a’ becomes ‘z’, ‘b’ becomes ‘y’, ‘c’ becomes ‘x’, etc. For instance, the word “vmxibkgrlm”, when decoded, would become “encryption”.
+
+Write a function called answer(s) which takes in a string and returns the deciphered string so you can show the commander proof that these minions are talking about “Lance & Janice” instead of doing their jobs.
+
+### Languages
+
+To provide a Python solution, edit solution.py
+
+To provide a Java solution, edit Solution.java
+
+### Test cases
+
+#### Test Case 1
+
+Inputs:
+```
+(string) s = “wrw blf hvv ozhg mrtsg’h vkrhlwv?”
+```
+Output:
+```
+(string) “did you see last night’s episode?”
+```
+
+#### Test Case 2
+
+Inputs:
+```
+(string) s = “Yvzs! I xzm’g yvorvev Lzmxv olhg srh qly zg gsv xlolmb!!”
+```
+Output:
+```
+(string) “Yeah! I can’t believe Lance lost his job at the colony!!”
+```
+
+### Constraints
+
+#### Java
+
+Your code will be compiled using standard Java 7. It must implement the answer() method in the solution stub.
+
+Execution time is limited. Some classes are restricted (e.g. java.lang.ClassLoader). You will see a notice if you use a restricted class when you verify your solution.
+
+Third-party libraries, input/output operations, spawning threads or processes and changes to the execution environment are not allowed.
+
+#### Python
+
+Your code will run inside a Python 2.7.6 sandbox.
+
+Standard libraries are supported except for bz2, crypt, fcntl, mmap, pwd, pyexpat, select, signal, termios, thread, time, unicodedata, zipimport, zlib.

Level 1/Minion Task Scheduling/readme.txt

@@ -0,0 +1,40 @@
+Minion Task Scheduling
+Time to solve: 24 hours.
+
+Description
+Commander Lambda's minions are upset! They're given the worst jobs on the whole space station, and some of them are starting to complain that even those worst jobs are being allocated unfairly. If you can fix this problem, it'll prove your chops to Commander Lambda so you can get promoted!
+
+Minion's tasks are assigned by putting their ID numbers into a list, one time for each day they'll work on that task. As shifts are planned well in advance, the lists for each task will contain up to 99 integers. When a minion is scheduled for the same task too many times, they'll complain about it until they're taken off the task completely. Some tasks are worse than others, so the number of scheduled assignments before a minion will refuse to do a task varies depending on the task. You figure you can speed things up by automating the removal of the minions who have been assigned a task too many times before they even get a chance to start complaining.
+
+Write a function called answer(data, n) that takes in a list of less than 100 integers and a number n, and returns that same list but with all of the numbers that occur more than n times removed entirely. The returned list should retain the same ordering as the original list - you don't want to mix up those carefully planned shift rotations! For instance, if data was [5, 10, 15, 10, 7] and n was 1, answer(data, n ) would return the list [5, 15, 7] because 10 occurs twice, and was thus removed from the list entirely.
+
+Languages
+To provide a Python solution, edit solution.py
+
+To provide a Java solution, edit solution.java
+
+Test Cases
+Test Case 1
+Inputs:
+
+(int list) data = [1, 2, 3]
+(int) n = 0
+Output:
+
+(int list) []
+Test Case 2
+Inputs:
+
+(int list) data = [1, 2, 2, 3, 3, 3, 4, 5, 5]
+(int) n = 1
+Output:
+
+(int list) [1, 4]
+Test Case 3
+Inputs:
+
+(int list) data = [1, 2, 3]
+(int) n = 6
+Output:
+
+(int list) [1, 2, 3]

Level 1/Minion Task Scheduling/solution.java

@@ -0,0 +1,76 @@
+package com.google.challenges;
+
+/**
+ * A brute force solution to the challenge, but considering there are only 100 integers
+ * in the array, it works.
+ */
+public class Answer {
+    
+    /**
+     * Actual method for the challenge.
+     *
+     * Will take in the array of integers data, and remove all instances of an element
+     * that appears more than n times.
+     *
+     * @param data: the array of integers to check
+     * @param n: the maximum number of times that an element can appear in the array
+     */
+    public static int[] answer(int[] data, int n) {
+        int i = 0;
+
+        //go through entire array (it will change size)
+        while (i < data.length) {
+            //element appears in array than n times
+            if (count(data, data[i]) > n ) {
+                //remove all instances of value in array
+                data = removeValue(data, data[i]); 
+            } else {
+                //it appears less than n times, so move to check next element
+                i++;
+            }
+        }
+        
+        return data; //return the newly trimmed array
+    }
+    
+    /**
+     * Will count the number of times an element (the number) appears in the array.
+     *
+     * @param data: the array of integers
+     * @param number: the number to check how many times it appears in the array
+     */
+    public static int count(int[] data, int number) {
+        int count = 0; //track number of times it appears
+        for (int i = 0; i < data.length; i++) {
+            if (data[i] == number) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+    
+    /**
+     * Will return a new array with all instances of the given number removed.
+     *
+     * @param data: the array of integers of which to remove the number
+     * @param number: the number to be removed from the array.
+     */
+    public static int[] removeValue(int[] data, int number) {
+        //integer holding length of the old array - the number of times
+        int newLength = data.length-count(data,number);
+        int[] newValues = new int[newLength]; //new array with the length
+        int track = 0; //index tracker for the new array
+
+        //iterate through the old array
+        for (int i = 0; i < data.length; i++) {
+            //if the current element is not the number
+            if (data[i] != number) {
+                newValues[track] = data[i]; //add it to the new array
+                track++; //increase the index tracker for the new array
+            }
+        }
+
+        return newValues; //return the new array
+    }
+}

Level 1/Minor Labor Shifts/readme.txt

@@ -0,0 +1,8 @@
+Minion Labor Shifts
+===================
+
+Commander Lambda's minions are upset! They're given the worst jobs on the whole space station, and some of them are starting to complain that even those worst jobs are being allocated unfairly. If you can fix this problem, it'll prove your chops to Commander Lambda so you can get promoted!
+
+Minions' tasks are assigned by putting their ID numbers into a list, one time for each day they'll work that task. As shifts are planned well in advance, the lists for each task will contain up to 99 integers. When a minion is scheduled for the same task too many times, they'll complain about it until they're taken off the task completely. Some tasks are worse than others, so the number of scheduled assignments before a minion will refuse to do a task varies depending on the task.  You figure you can speed things up by automating the removal of the minions who have been assigned a task too many times before they even get a chance to start complaining.
+
+Write a function called solution(data, n) that takes in a list of less than 100 integers and a number n, and returns that same list but with all of the numbers that occur more than n times removed entirely. The returned list should retain the same ordering as the original list - you don't want to mix up those carefully-planned shift rotations! For instance, if data was [5, 10, 15, 10, 7] and n was 1, solution(data, n) would return the list [5, 15, 7] because 10 occurs twice, and thus was removed from the list entirely.

Level 1/Minor Labor Shifts/solution.py

@@ -0,0 +1,7 @@
+import collections
+
+def solution(data, n):
+    if len(data) >= 100:
+        return None, None
+    occurrences = collections.Counter(data)
+    return [k for k in data if occurrences[k] <= n]

Level 1/Prison Labor Dodgers/__init__.py

@@ -0,0 +1,5 @@
+def answer(x, y):
+    # find symmetric difference between the two sets
+    diff = list(set(x) ^ set(y))
+    # return fist item in output list
+    return diff[0]

Level 1/Prison Labor Dodgers/solution.py

@@ -0,0 +1,19 @@
+import unittest
+from . import solution
+
+class TestCase(unittest.TestCase):
+    def test_case_1(self):
+        self.assertEqual(
+            solution.answer(
+                [13, 5, 6, 2, 5],
+                [5, 2, 5, 13],
+            ), 6
+        )
+
+    def test_case_2(self):
+        self.assertEqual(
+            solution.answer(
+                [14, 27, 1, 4, 2, 50, 3, 1],
+                [2, 4, -4, 3, 1, 1, 14, 27, 50],
+            ), -4
+        )

Level 1/Prison Labor Dodgers/test.py

@@ -0,0 +1,16 @@
+	Re-ID
+	=====
+	There's some unrest in the minion ranks: minions with ID numbers like "1", "42", and other "good" numbers have been 
+	lording it over the poor minions who are stuck with more boring IDs. To quell the unrest, Commander Lambda has tasked 
+	you with reassigning everyone new, random IDs based on her Completely Foolproof Scheme.
+	She's concatenated the prime numbers in a single long string: "2357111317192329...". Now every minion must draw a 
+	number from a hat. That number is the starting index in that string of primes, and the minion's new ID number will be 
+	the next five digits in the string. So if a minion draws "3", their ID number will be "71113".
+	Help the Commander assign these IDs by writing a function answer(n) which takes in the starting index n of Lambda's 
+	string of all primes, and returns the next five digits in the string. Commander Lambda has a lot of minions, so the 
+	value of n will always be between 0 and 10000.
+
+	Test cases
+	Inputs: (int) n = 0 Output: (string) "23571"
+
+	Inputs: (int) n = 3 Output: (string) "71113"