From 3bade9a3c6bb2b3ec4706b1b2e776c24ff2dded8 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:15:40 -0600 Subject: [PATCH 01/20] Foregone Solution solution - Gonzalo Martinez --- .../java/foregone-solution.java | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 solutions/foregone-solution/java/foregone-solution.java diff --git a/solutions/foregone-solution/java/foregone-solution.java b/solutions/foregone-solution/java/foregone-solution.java new file mode 100644 index 00000000..86cef9c8 --- /dev/null +++ b/solutions/foregone-solution/java/foregone-solution.java @@ -0,0 +1,30 @@ +import java.util.Scanner; +public class Foregone { + public static void main(String[] args) { + Scanner input = new Scanner(System.in); + int t = input.nextInt(); + + for (int i = 1; i <= t; i++ ) { + String n = input.next(); + foregoneAlgorithm(i, n); + } + input.close(); + } + public static void foregoneAlgorithm(int t, String n) { + String[] substrings = n.split(""); + + String a = ""; + String b = ""; + + for(String i : substrings) { + if (i.equals("4")){ + a = a.concat("2"); + b = b.concat("2"); + } else { + a = a.concat(i); + b = b.concat("0"); + } + } + System.out.println("Case #"+ t + ": " + a + " " + b); + } +} From 1bfb1c4702929a90c5a6e69c73024521c0570847 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:16:45 -0600 Subject: [PATCH 02/20] Foregone Solution solution - Alejandro Mendoza --- .../lisp/foregone-solution.lisp | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 solutions/foregone-solution/lisp/foregone-solution.lisp diff --git a/solutions/foregone-solution/lisp/foregone-solution.lisp b/solutions/foregone-solution/lisp/foregone-solution.lisp new file mode 100644 index 00000000..28048fb5 --- /dev/null +++ b/solutions/foregone-solution/lisp/foregone-solution.lisp @@ -0,0 +1,38 @@ +;;; Function that calculates the amount for each check +(defun get-check-amounts(num) + (let ((a nil)) ; Create a local variable for the check a + (let ((b nil)) ; Create a local variable for the check b + + (loop for c across num do ; Loop across the string + (if (string= c "4") ; If we find a 4 + (progn + (setf a (cons '2 a)) ; We add a 2 to list a + (setf b (cons '2 b)) ; We add a 2 to list b + ) + (progn ; If we dont find a 4 + (setf a (cons c a)) ; We add the number to list a + (if b ; If b doesnt have a value + ; We check this, so that there are no leading 0s + (setf b (cons '0 b)) ; We add a 0 to list b + ) + ) + ) + ) + (values (reverse a) (reverse b)) ; We return both lists + )) +) + +;;; Function that solves a test case +(defun solve(casenum) + (let ((num (read-line))) ; Read number + (multiple-value-bind (a b) (get-check-amounts num) + (format t "Case #~d: ~{~d~} ~{~d~}~%" casenum a b)) +)) + +;;; Read the amount of test cases +(defvar *cases* (read)) + +;;; Run the solve function for each test case +(loop for x from 1 to *cases* do + (solve x) +) \ No newline at end of file From f39b2f2ea9ee96757471827e0568959d0116a6f0 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:17:50 -0600 Subject: [PATCH 03/20] Foregone Solution solution - Abraham Ramirez --- .../foregone-solution/go/foregone-solution.go | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 solutions/foregone-solution/go/foregone-solution.go diff --git a/solutions/foregone-solution/go/foregone-solution.go b/solutions/foregone-solution/go/foregone-solution.go new file mode 100644 index 00000000..24c26a1d --- /dev/null +++ b/solutions/foregone-solution/go/foregone-solution.go @@ -0,0 +1,38 @@ +package main + +import ( + "fmt" + "strconv" +) + +// Just for the reading of the test cases +func main(){ + var T int + fmt.Scanf("%d", &T) + for caseNumber := 1; caseNumber <= T ; caseNumber++{ + A, B := foregone() + fmt.Printf("Case #%d: %s %s\n", caseNumber, A, B) + } + +} + +// The solution of the actual problem +func foregone() (A, B string) { + var N string + fmt.Scanf("%s", &N) + var four string = strconv.Itoa(4) + A = "" + B = "" + + for _, char := range N { + if c := string(char); four == c { + A += "2" + B += "2" + } else { + A += c + B += "0" + } + } + + return +} \ No newline at end of file From 6fdb0732fad327ca1e64c32f696a02a9d5ecfffd Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:18:27 -0600 Subject: [PATCH 04/20] Foregone Solution solution - Alondra Galvan --- .../python/foregone-solution.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 solutions/foregone-solution/python/foregone-solution.py diff --git a/solutions/foregone-solution/python/foregone-solution.py b/solutions/foregone-solution/python/foregone-solution.py new file mode 100644 index 00000000..1f40025f --- /dev/null +++ b/solutions/foregone-solution/python/foregone-solution.py @@ -0,0 +1,16 @@ +## input: +# T: number of test cases +# N: for each test case, N is the number of jamcoins, has at least a 4 +## output: +# A,B: Two integers that have no 4's and A+B = N + +T = int(input()) + +for j in range(T): + N = input() + idx = -1 + A = 0 + for i in range(N.count('4') ): # get each 4 position + idx = N.find('4', idx + 1, len(N)) + A = A + 2*10**(len(N)-idx-1) # Set a 2 in said position in A, it will have a 0 if it is not a 4 in N + print('Case #%d: %d %d'%((j+1),(int(N) - A), A)) # Return A and B = N - A \ No newline at end of file From 4d23926311f045ae0569ddfd4bd24c359e581135 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:19:28 -0600 Subject: [PATCH 05/20] docs: Foregone Solution added readme file --- solutions/foregone-solution/README.md | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 solutions/foregone-solution/README.md diff --git a/solutions/foregone-solution/README.md b/solutions/foregone-solution/README.md new file mode 100644 index 00000000..29f31f38 --- /dev/null +++ b/solutions/foregone-solution/README.md @@ -0,0 +1,7 @@ +# Foregone Solution + +Someone just won the Code Jam lottery, and we owe them N jamcoins! However, when we tried to print out an oversized check, we encountered a problem. The value of N, which is an integer, includes at least one digit that is a 4... and the 4 key on the keyboard of our oversized check printer is broken. + +Fortunately, we have a workaround: we will send our winner two checks for positive integer amounts A and B, such that neither A nor B contains any digit that is a 4, and A + B = N. Please help us find any pair of values A and B that satisfy these conditions. + +More details: https://codingcompetitions.withgoogle.com/codejam/round/0000000000051705/0000000000088231 From be94086c13cb6a6f536dc8d11633ee272c16e333 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:21:58 -0600 Subject: [PATCH 06/20] Nesting Depth solution - Gonzalo Martinez --- .../nesting-depth/java/nesting-depth.java | 79 +++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 solutions/nesting-depth/java/nesting-depth.java diff --git a/solutions/nesting-depth/java/nesting-depth.java b/solutions/nesting-depth/java/nesting-depth.java new file mode 100644 index 00000000..924f9f23 --- /dev/null +++ b/solutions/nesting-depth/java/nesting-depth.java @@ -0,0 +1,79 @@ +import java.util.Scanner; + +public class NestingDepth { + public static void main(String[] args) { + Scanner input = new Scanner(System.in); + int t = input.nextInt(); + + for (int i = 1; i <= t; i++ ) { + String n = input.next(); + nestingAlgorithm(i, n); + } + input.close(); + } + + public static void nestingAlgorithm(int t, String s) { + s = "0" + s + "0"; + String[] substrings = s.split(""); + + String[] newArray = substrings; + + int count = 0; + + for(int i = 1; i < substrings.length; i++) { + int dif = substrings[i].compareTo(substrings[i-1]); + int abs = Math.abs(dif); + int index = i + count; + + if (dif > 0) { + newArray = addOpeningParenthesis(newArray, index, abs); + count++; + } else if (dif < 0){ + newArray = addClosingParenthesis(newArray, index, abs); + count++; + } + + } + + String result = String.join("", newArray); + result = result.substring(1, result.length()-1); + + System.out.println("Case #"+ t + ": " + result); + } + + public static String[] addClosingParenthesis(String[] array, int index, int times) { + String parenthesis = ")".repeat(times); + String[] newArray = new String[array.length + 1]; + + int j = 0; + + for(int i = 0; i < newArray.length; i++) { + if(i == index) { + newArray[i] = parenthesis; + }else { + newArray[i] = array[j]; + j++; + } + } + + return newArray; + } + + public static String[] addOpeningParenthesis(String[] array, int index, int times) { + String parenthesis = "(".repeat(times); + String[] newArray = new String[array.length + 1]; + + int j = 0; + + for(int i = 0; i < newArray.length; i++) { + if(i == index) { + newArray[i] = parenthesis; + }else { + newArray[i] = array[j]; + j++; + } + } + + return newArray; + } +} From ab113a373f768b4213101009e4a15d31f341d942 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:23:01 -0600 Subject: [PATCH 07/20] Nesting Depth solution - Oscar Garzon --- .../nesting-depth/lisp/nesting-depth.lisp | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 solutions/nesting-depth/lisp/nesting-depth.lisp diff --git a/solutions/nesting-depth/lisp/nesting-depth.lisp b/solutions/nesting-depth/lisp/nesting-depth.lisp new file mode 100644 index 00000000..89e33042 --- /dev/null +++ b/solutions/nesting-depth/lisp/nesting-depth.lisp @@ -0,0 +1,30 @@ +(defun add_parenthesis (parenthesis s) + "If parenthesis > 0 adds '(' parenthesis times. If < 0 adds ')' parenthesis times. + If parenthesis equals 0 return the unmodified string" + (cond ((zerop parenthesis) s) + ((plusp parenthesis) (add_parenthesis (1- parenthesis) (concatenate 'string s "("))) + ((minusp parenthesis) (add_parenthesis (1+ parenthesis) (concatenate 'string s ")"))))) + +(defun nesting_depth (number_string final_string open_parenthesis) + "Given a string of digits S, insert a minimum number of opening and closing parentheses + into it such that the resulting string is balanced and each digit d is inside exactly d + pairs of matching parentheses." + (if (equal number_string "") + (add_parenthesis (* -1 open_parenthesis) final_string) ;; Close the last opened parenthesis + (let* ((digit_number (digit-char-p (char number_string 0))) + (digit_string (write-to-string digit_number))) + (if (= digit_number open_parenthesis) ;; open parenthesis match the digit, hence concatenates the digit + (nesting_depth (subseq number_string 1) + (concatenate 'string final_string digit_string) + digit_number) + (nesting_depth (subseq number_string 1) ;; parnthesis needs to be open or close before concatenating the digit + (concatenate 'string (add_parenthesis (- digit_number open_parenthesis) + final_string) + digit_string) + digit_number))))) + +(defun main () + (loop for test from 1 to (parse-integer (read-line)) do + (setf result (nesting_depth (read-line) "" 0)) + (format t "Case #~d: ~d~%" test result))) +(main) \ No newline at end of file From 8b2ef7b4e834d61dfb1fb5d0a7d1bfd9687d07a1 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:23:44 -0600 Subject: [PATCH 08/20] Nesting Depth solution - Abraham Ramirez --- solutions/nesting-depth/go/nesting-depth.go | 52 +++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 solutions/nesting-depth/go/nesting-depth.go diff --git a/solutions/nesting-depth/go/nesting-depth.go b/solutions/nesting-depth/go/nesting-depth.go new file mode 100644 index 00000000..d79119fd --- /dev/null +++ b/solutions/nesting-depth/go/nesting-depth.go @@ -0,0 +1,52 @@ +package main + +import ( + "fmt" + "math" + "strconv" +) + +// Just for the testcases +func main() { + var T int + fmt.Scanf("%d", &T) + for caseNumber := 1; caseNumber <= T; caseNumber++ { + S := nestingDepth() + fmt.Printf("Case #%d: %s\n", caseNumber, S) + } +} + +// The solution +func nestingDepth() (nestingS string) { + var S string + var parentesisAbiertos int = 0 + fmt.Scanf("%s", &S) + + nestingS = "" + + for _, val := range S { + char := string(val) + + if digit, _ := strconv.Atoi(char); parentesisAbiertos == digit { + nestingS += char + } else if remain := digit - parentesisAbiertos; remain > 0 { + for i := 0; i < remain; i++ { + nestingS += "(" + parentesisAbiertos++ + } + nestingS += char + } else { + for i := 0; i < int(math.Abs(float64(remain))); i++ { + nestingS += ")" + parentesisAbiertos-- + } + nestingS += char + } + } + + for i := 0; i < parentesisAbiertos; i++ { + nestingS += ")" + } + + return +} From 2f311d555fd71ec5956113482f29fa5b004f50bb Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:24:47 -0600 Subject: [PATCH 09/20] Nesting Depth solution - Aldo Santiago --- .../nesting-depth/python/nesting-depth.py | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 solutions/nesting-depth/python/nesting-depth.py diff --git a/solutions/nesting-depth/python/nesting-depth.py b/solutions/nesting-depth/python/nesting-depth.py new file mode 100644 index 00000000..b9d78dfc --- /dev/null +++ b/solutions/nesting-depth/python/nesting-depth.py @@ -0,0 +1,36 @@ +"""Nesting Depth + +This is a solution for the Google Code Jam 'Nesting Depth' problem +Given a string of digits S, insert a minimum number of opening and +closing parentheses into it such that the resulting string +is balanced and each digit d is inside exactly d pairs of matching parentheses + +The first line of the input gives the number of test cases, T. +T lines follow. Each line represents a test case and contains only the string S + +More information: +https://codingcompetitions.withgoogle.com/ + codejam/round/000000000019fd27/0000000000209a9f +""" + +def solve(s): + s = '0' + s + '0' + diff = 0 + i = 1 + while i < len(s): + # inserts parenthesis based on difference between digits + diff = int(s[i]) - int(s[i-1]) + if diff > 0: + s = s[:i] + ('(' * abs(diff)) + s[i:] + elif diff < 0: + s = s[:i] + (')' * abs(diff)) + s[i:] + + # next iteration will be next digit and not a parenthesis + i += abs(diff) + 1 + + return s[1:-1] # remove extra zeros added at the beginning + +t = int(input()) + +for i in range(1, t + 1): + print(f'Case #{i}: {solve(input())}') From 1f0b077174a3ff90e4665f9c7dfdedaf697d3b4f Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 17:25:15 -0600 Subject: [PATCH 10/20] docs: Nesting Depth added readme file --- solutions/nesting-depth/README.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 solutions/nesting-depth/README.md diff --git a/solutions/nesting-depth/README.md b/solutions/nesting-depth/README.md new file mode 100644 index 00000000..104b19e9 --- /dev/null +++ b/solutions/nesting-depth/README.md @@ -0,0 +1,16 @@ +# Nesting Depth + +Given a string of digits S, insert a minimum number of opening and closing parentheses into it such that the resulting string is balanced and each digit d is inside exactly d pairs of matching parentheses. + +Let the nesting of two parentheses within a string be the substring that occurs strictly between them. An opening parenthesis and a closing parenthesis that is further to its right are said to match if their nesting is empty, or if every parenthesis in their nesting matches with another parenthesis in their nesting. The nesting depth of a position p is the number of pairs of matching parentheses m such that p is included in the nesting of m. + +For example, in the following strings, all digits match their nesting depth: 0((2)1), (((3))1(2)), ((((4)))), ((2))((2))(1). The first three strings have minimum length among those that have the same digits in the same order, but the last one does not since ((22)1) also has the digits 221 and is shorter. + +Given a string of digits S, find another string S', comprised of parentheses and digits, such that: + +- all parentheses in S' match some other parenthesis +- removing any and all parentheses from S' results in S +- each digit in S' is equal to its nesting depth +- S' is of minimum length + +More details: https://codingcompetitions.withgoogle.com/codejam/round/000000000019fd27/0000000000209a9f From c0d3dc410f3911d2cba00e0e59b190038e22e22d Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 18:54:06 -0600 Subject: [PATCH 11/20] You Can Go Your Own Way java sol - Gustavo Higuera --- .../java/you-can-go-your-own-way.java | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 solutions/you-can-go-your-own-way/java/you-can-go-your-own-way.java diff --git a/solutions/you-can-go-your-own-way/java/you-can-go-your-own-way.java b/solutions/you-can-go-your-own-way/java/you-can-go-your-own-way.java new file mode 100644 index 00000000..db851bb7 --- /dev/null +++ b/solutions/you-can-go-your-own-way/java/you-can-go-your-own-way.java @@ -0,0 +1,32 @@ +import java.util.Scanner; + +class Solution { + + public static void main(String[] args){ + Scanner input = new Scanner(System.in); + int t = input.nextInt(); + + for (int i=1; i<=t; i++) { + int n = input.nextInt(); + String s = input.next(); + resolve(i, n, s); + } + + input.close(); + } + + public static void resolve(int t, int n, String s) { + StringBuffer newStr = new StringBuffer(s); + + for(int i = 0; i < s.length(); i++){ + if(s.charAt(i) == 'S' || s.charAt(i) == 's'){ + newStr.setCharAt(i, 'E'); + } else if(s.charAt(i) == 'E' || s.charAt(i) == 'e'){ + newStr.setCharAt(i, 'S'); + } + } + + + System.out.println("Case #" + t + ": " + newStr); + } +} From 4eb88345b7cc14a9cb109f24854f5641a0df3bd2 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 18:55:17 -0600 Subject: [PATCH 12/20] You Can Go Your Own Way lisp sol - Alejandro M --- .../lisp/you-can-go-your-own-way.lisp | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 solutions/you-can-go-your-own-way/lisp/you-can-go-your-own-way.lisp diff --git a/solutions/you-can-go-your-own-way/lisp/you-can-go-your-own-way.lisp b/solutions/you-can-go-your-own-way/lisp/you-can-go-your-own-way.lisp new file mode 100644 index 00000000..6ea8c49e --- /dev/null +++ b/solutions/you-can-go-your-own-way/lisp/you-can-go-your-own-way.lisp @@ -0,0 +1,26 @@ +;;; Function that swaps all S's with E's and vice versa +(defun invert-path(path) + (let ((new-path nil)) ; Create a local variable for new list + (loop for c across path do ; Loop across Lydia's path + (if (string= c "S") ; If the char is an "S" + (setf new-path (cons 'E new-path)) ; Add an E to the list + (setf new-path (cons 'S new-path)) ; If not, add an S to the list + ) + ) + (return-from invert-path (reverse new-path)) ; Return new list +)) + +;;; Function that solves a test case +(defun solve(casenum) + (let ((maze-size (read))) ; Read the maze size + (let ((path (read-line))) ; Read Lydia's path + (format t "Case #~d: ~{~d~}~%" casenum (invert-path path)) +))) + +;;; Read the amount of test cases +(defvar *cases* (read)) + +;;; Run the solve function for each test case +(loop for x from 1 to *cases* do + (solve x) +) \ No newline at end of file From 2866bf756878f41f6bab59676c4c21b909b70262 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 18:56:27 -0600 Subject: [PATCH 13/20] You Can Go Your Own Way go sol - Juan Sanchez --- .../go/you-can-go-your-own-way.go | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 solutions/you-can-go-your-own-way/go/you-can-go-your-own-way.go diff --git a/solutions/you-can-go-your-own-way/go/you-can-go-your-own-way.go b/solutions/you-can-go-your-own-way/go/you-can-go-your-own-way.go new file mode 100644 index 00000000..69c1ca9e --- /dev/null +++ b/solutions/you-can-go-your-own-way/go/you-can-go-your-own-way.go @@ -0,0 +1,36 @@ +package main + +import ( + "bufio" + "fmt" + . "fmt" + . "os" +) + +var rd *bufio.Reader = bufio.NewReader(Stdin) +var wr *bufio.Writer = bufio.NewWriter(Stdout) + +func main() { + var T, N int + var S string + + Scanf("%d", &T) + + for i := 1; i <= T; i++ { + var sol string + sol = "" + Scanf("%d", &N) + Scanf("%s", &S) + + for _, ch := range S { + if ch == 83 { + sol += "E" + } else { + sol += "S" + } + } + fmt.Printf("Case #%d: %s\n", i, sol) + defer wr.Flush() + } + +} From 97d6e844896a0a0283b309b2257e042d6bdc7961 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 18:57:04 -0600 Subject: [PATCH 14/20] You Can Go Your Own Way python sol - Alondra G --- .../python/you-can-go-your-own-way.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 solutions/you-can-go-your-own-way/python/you-can-go-your-own-way.py diff --git a/solutions/you-can-go-your-own-way/python/you-can-go-your-own-way.py b/solutions/you-can-go-your-own-way/python/you-can-go-your-own-way.py new file mode 100644 index 00000000..f870e3c9 --- /dev/null +++ b/solutions/you-can-go-your-own-way/python/you-can-go-your-own-way.py @@ -0,0 +1,19 @@ + +## input: +# T: number of test cases +# N: grid will have NxN size +# y: String that represents Lydia's path, it has N-1 characters +## output: +# path that will not have a step as Lydias' one +T = int(input()) # numero de casos de prueba + +for j in range(T): + N = input() #ni siquiera voy a usar esta variable + y = input() + sol = "" + for l in y: # for each step in Lydia's Path, we take the opposite step + if l == 'S': + sol = sol + 'E' + else: + sol = sol + 'S' + print('Case #%d: %s'%((j+1),sol)) # return new path \ No newline at end of file From 3b9d3b7608f5beb75c185f5e7dfee96958c105f6 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 18:57:29 -0600 Subject: [PATCH 15/20] docs: You Can Go Your Own Way added readme file --- solutions/you-can-go-your-own-way/README.md | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 solutions/you-can-go-your-own-way/README.md diff --git a/solutions/you-can-go-your-own-way/README.md b/solutions/you-can-go-your-own-way/README.md new file mode 100644 index 00000000..2a5b8d1a --- /dev/null +++ b/solutions/you-can-go-your-own-way/README.md @@ -0,0 +1,9 @@ +# You Can Go Your Own Way + +You have just entered the world's easiest maze. You start in the northwest cell of an N by N grid of unit cells, and you must reach the southeast cell. You have only two types of moves available: a unit move to the east, and a unit move to the south. You can move into any cell, but you may not make a move that would cause you to leave the grid. + +You are excited to be the first in the world to solve the maze, but then you see footprints. Your rival, Labyrinth Lydia, has already solved the maze before you, using the same rules described above! + +As an original thinker, you do not want to reuse any of Lydia's moves. Specifically, if her path includes a unit move from some cell A to some adjacent cell B, your path cannot also include a move from A to B. (However, in that case, it is OK for your path to visit A or visit B, as long as you do not go from A to B.) Please find such a path. + +More details: https://codingcompetitions.withgoogle.com/codejam/round/0000000000051705/00000000000881da From 8b0abf1520fd3e0f121c373cebe35e44e3c8e4ad Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 18:58:06 -0600 Subject: [PATCH 16/20] ESAb ATAd java solution - Gustavo Higuera --- solutions/esab-atad/java/esab-atad.java | 112 ++++++++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 solutions/esab-atad/java/esab-atad.java diff --git a/solutions/esab-atad/java/esab-atad.java b/solutions/esab-atad/java/esab-atad.java new file mode 100644 index 00000000..5876e84d --- /dev/null +++ b/solutions/esab-atad/java/esab-atad.java @@ -0,0 +1,112 @@ +import java.util.Scanner; + +class Solution { + + public static Scanner sc= new Scanner(System.in); + public static int count = 0; + + public static void fillArray(int arr[]){ + int size = arr.length; + for (int i = 0; i < size; i++){ + arr[i] = 0; + } + } + + public static void printArray(int arr[]){ + int size = arr.length; + for (int i = 0; i < size; i++){ + System.out.print(arr[i]); + } + System.out.print("\n"); + } + + public static void complement(int arr[]){ + int size = arr.length; + for (int i = 0; i < size; i++){ + arr[i] ^= 1; + } + } + + public static void reverse(int arr[]){ + int size = arr.length; + int tmp = 0; + for (int i = 0; i < Math.floor(size/2); i++){ + tmp = arr[i]; + arr[i] = arr[size-1-i]; + arr[size-1-i] = tmp; + } + } + + public static int query(int i){ + + if(i != -1){ + System.out.print(i+1); + } + else{ + System.out.print("1"); + } + System.out.print("\n"); + count++; + int input = sc.nextInt(); + sc.nextLine(); + return input; + } + + public static void checkCorrect(int arr[]){ + printArray(arr); + String input = sc.nextLine(); + + if (!input.equals("Y")) + System.exit(0); + + } + + public static void esab_atad(int B){ + int result[] = new int[B]; + int complement_i = -1; + int reverse_i = -1; + int complement_res = 0; + int reverse_res = 0; + count = 0; + fillArray(result); + for (int i = 0; i < Math.floor(B / 2); i++){ + if(count != 0 && count%10 == 0){ + complement_res = query(complement_i); + reverse_res = query(reverse_i); + + if ( complement_i != -1 && (result[complement_i]^complement_res) == 1) + complement(result); + + if ( reverse_i != -1 && (result[reverse_i]^reverse_res) == 1 + ) + reverse(result); + } + + result[i] = query(i); + + result[B-i-1] = query(B-i-1); + + if( result[i] == result[B-i-1]) + complement_i = i; + else + reverse_i = i; + } + checkCorrect(result); + } + + public static void main(String[] args) { + int T; + int B; + String input; + String[] inputSplit; + input = sc.nextLine(); + inputSplit = input.split(" "); + + T = Integer.parseInt(inputSplit[0]); + B = Integer.parseInt(inputSplit[1]); + + for (int i = 0; i < T; i++){ + esab_atad(B); + } + } +} From 83cebfeff253d94fa29f72c6ea12f3a9891a539c Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 18:59:06 -0600 Subject: [PATCH 17/20] ESAb ATAd lisp solution - Oscar G & Alejandro M --- solutions/esab-atad/lisp/esab-atad.lisp | 145 ++++++++++++++++++++++++ 1 file changed, 145 insertions(+) create mode 100644 solutions/esab-atad/lisp/esab-atad.lisp diff --git a/solutions/esab-atad/lisp/esab-atad.lisp b/solutions/esab-atad/lisp/esab-atad.lisp new file mode 100644 index 00000000..4ed29842 --- /dev/null +++ b/solutions/esab-atad/lisp/esab-atad.lisp @@ -0,0 +1,145 @@ +;; Function that gets a bit from the judge +(defun get-bit (idx) + (if (not idx) + (progn (format t "~d~%" 1) ;; In case idx is nil + (finish-output) + (parse-integer (read-line)) + nil) + (progn (format t "~d~%" (1+ idx)) ;; idx is a valid number + (finish-output) + (parse-integer (read-line))))) + +;; Function to query a pair of bits +(defun get-pair (left-idx) + (values (get-bit left-idx) (get-bit (- +number-length+ left-idx 1)))) ;; Return the left bit an its counterpart + +; Function that returns true if left and right are symmetric (equal) +(defun symmetricp (left right) + (= left right)) + +;; Function that checks if the digit has changed after fluctuation +(defun digit-changed (old-value new-value) + (/= old-value new-value)) + +;; Function that returns the type of fluctuation when we have both pairs +(defun get-fluctuation-sym-asym (old-sym-value old-asym-value new-sym-value new-asym-value) + (cond + ((and (/= old-sym-value new-sym-value) + (/= old-asym-value new-asym-value)) + ; Symmetrical AND asymmetrical changed + "C") + ((/= old-sym-value new-sym-value) ; Only symmetrical changed + "CR") + ((/= old-asym-value new-asym-value) ; Only asymmetrical changed + "R") + (t "N")) ; Neither changed + ) + +;; Function that returns the fluctuation type when we have only a symmetrical pair +(defun get-fluctuation-sym (old-sym-value new-sym-value) + (if (/= old-sym-value new-sym-value) + "C" + "N")) + +;; Function that returns the fluctuation type when we have only an asymmetrical pair +(defun get-fluctuation-asym (old-asym-value new-asym-value) + (if (/= old-asym-value new-asym-value) + "C" + "N")) + +;; Function that gets the fluctuation type, calls helper functions +(defun get-fluctuation-type (old-sym-value old-asym-value new-sym-value new-asym-value ) + (cond ( (and old-sym-value old-asym-value) ; We have both pairs stored + (get-fluctuation-sym-asym old-sym-value old-asym-value new-sym-value new-asym-value)) ; Call helper function + ; We only have one pair + ( old-sym-value ; We only have sym + (get-fluctuation-sym old-sym-value new-sym-value) ; Call helper function + ) + ; We only have asym + (t (get-fluctuation-asym old-asym-value new-asym-value)) ; Call helper function + ) +) + +;; Function that changes 0s to 1s and viceversa .VERIFICAR CUANDO ELEMENTO DE ARR ES NIL +(defun complement-array (arr) ; bit index) + (loop for i from 0 to (- +number-length+ 1) do ; Loop through the array + (if (eql (aref arr i) 0) ; If the current bit is a 0 + (setf (elt arr i) 1) ; Set the bit to a 1 + (setf (elt arr i) 0) ; Set the bit to a 0 +))) + +;; Function that updates our stored array +(defun update-array (arr bit-index fluct-type) + (cond ( (equal fluct-type "C") ; If the fluctuation type is a C + (complement-array arr ) ; We complement the array + ) + ( (equal fluct-type "R") ; If the fluctuation type is an R + (setf arr (nreverse arr)) ; We reverse the array + ) + ( (equal fluct-type "CR") ; If the fluctuation type is a CR + (complement-array arr) ; We complement the array + (setf arr (nreverse arr)) ; We also reverse the array + ) + (t nil) ; We leave our array the same + ) +) + +;; Helper function to convert an array to a list +(defun array-to-list (array) + (map 'list #'identity array)) + +;; Helper function that splits the input into ints +(defun split-space (s) + (let ( (space-idx (position #\Space s))) + ;Return inputs as ints + (values (parse-integer (subseq s 0 space-idx)) (parse-integer (subseq s (1+ space-idx))) ))) + +;; Function that solves a test case +(defun solve-test-case (length) + ;; Solve cases + (defconstant +number-length+ length) ; Define constant length of arrays + (defparameter arr (make-array +number-length+ :initial-element nil)) ; Create empty array of the length inputed + ; Declare symmetrical and asymmetrical indexes, number of queries and current index + (let ((sym-index nil) + (asym-index nil) + (queries 0) + (bit-index 0)) + (loop + (when (= bit-index (floor (/ +number-length+ 2))) (return)) ; Loop through the half of the array + (multiple-value-bind (left right) (get-pair bit-index) ; Declare left and right values + (setf queries (+ queries 2)) ; Add 2 to the queries + (if (or (not sym-index) (not asym-index)) ; If we dont have a sym or asym pair + (if (symmetricp left right) ; Check if its symmetrical + (if (not sym-index) (setf sym-index bit-index)) ; Set sym index, if we dont have one + (if (not asym-index) (setf asym-index bit-index)))) ; Set asym index, if we dont have one + + (if (and (= (mod queries 10) 2) (/= bit-index 0)) ; Check if a fluctuation happened + (progn + (let ((new-sym-value (get-bit sym-index)) ; Get fluctuation and update accordingly + (new-asym-value (get-bit asym-index)) + (old-sym-value (if (not sym-index) nil (elt arr sym-index))) + (old-asym-value (if (not asym-index) nil (elt arr asym-index)))) + (update-array arr + bit-index + (get-fluctuation-type old-sym-value + old-asym-value + new-sym-value + new-asym-value))) + (setf queries (+ queries 2))) ; Add 2 to the queries + ) + (setf (elt arr bit-index) left) ; Set new left value + (setf (elt arr (- +number-length+ bit-index 1)) right) ; Set new right value + (setf bit-index (1+ bit-index)) ; Add one to the current index + )) + (format t "~{~d~}~%" (array-to-list arr)))) ; Print array + +(defun main () + (setf in (read-line)) ; Read input + (multiple-value-bind (test-cases length) (split-space in) ; Format input into test-cases and length + (loop for test from 0 to (- test-cases 1) do ; Loop test-cases times + (solve-test-case length) + (setf result (read-line)) + (if (equal result "N") (return))) ; If we got a wrong answer, stop the program + )) + +(main) \ No newline at end of file From cad85bdec1ecff6c5c9c243dfc8b9037a8d93c9a Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 19:00:13 -0600 Subject: [PATCH 18/20] ESAb ATAd go solution - Juan Sanchez --- solutions/esab-atad/go/esab-atad.go | 98 +++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 solutions/esab-atad/go/esab-atad.go diff --git a/solutions/esab-atad/go/esab-atad.go b/solutions/esab-atad/go/esab-atad.go new file mode 100644 index 00000000..4e12812b --- /dev/null +++ b/solutions/esab-atad/go/esab-atad.go @@ -0,0 +1,98 @@ +package main + +import ( + "bufio" + . "fmt" // Like C++ with the namespace, you use the functions without the 'fmt.' part + . "os" +) + +var B, T int //where B is the size of the test, and T the number of Test Sets + +var rd *bufio.Reader = bufio.NewReader(Stdin) +var wr *bufio.Writer = bufio.NewWriter(Stdout) + +func main() { + Scanf("%d%d", &T, &B) + //Iterate trought all the cases + for i := 1; i <= T; i++ { + var DB = make([]int, B+1) + var L int = 1 + var R int = B + for Q := 1; true; Q += 2 { //To keep an eye to the query number + if Q%10 == 1 && Q != 1 { + p := -1 + asim := -1 + for i := 1; i < L; i++ { + if DB[i] == DB[B+1-i] { + p = i + } else { + asim = i + } + } + if p == -1 { + status := query(1) + query(1) + if status != DB[1] { + for i := 1; i <= L; i++ { + DB[i] ^= 1 + } + for i := R; i <= B; i++ { + DB[i] ^= 1 + } + } + } else { + status := query(p) + if status != DB[p] { + for i := 1; i <= L; i++ { + DB[i] ^= 1 + } + for i := R; i <= B; i++ { + DB[i] ^= 1 + } + } + if asim == -1 { + query(p) + } else { + if query(asim) != DB[asim] { + for i, j := 1, len(DB)-1; i < j; i, j = i+1, j-1 { + DB[i], DB[j] = DB[j], DB[i] + } + } + } + } + Q += 2 + } + DB[L] = query(L) + DB[R] = query(R) + L += 1 + R -= 1 + if L > R { //Means that we already have all the database + for i := 1; i <= B; i++ { + Printf("%d", DB[i]) + } + Println() + var res string + Scanf("%s", &res) + if res == "N" { //Exit in case that our response is incorrect + Exit(0) + } else { + break + } + + } + } + } +} + +// To ask for a bit inside the database +func query(pos int) int { + Printf("%d\n", pos) + defer wr.Flush() + var bit int + Scanf("%d", &bit) + return bit +} + +//Let me out of go jaj +//Note: Go is a good language, the thing was that +//I just used to much python. From a265aec4bbc08cc593833739f2b00d6ef57a323c Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 19:00:29 -0600 Subject: [PATCH 19/20] ESAb ATAd python solution - Aldo Santiago --- solutions/esab-atad/python/esab-atad.py | 130 ++++++++++++++++++++++++ 1 file changed, 130 insertions(+) create mode 100644 solutions/esab-atad/python/esab-atad.py diff --git a/solutions/esab-atad/python/esab-atad.py b/solutions/esab-atad/python/esab-atad.py new file mode 100644 index 00000000..88c41fcc --- /dev/null +++ b/solutions/esab-atad/python/esab-atad.py @@ -0,0 +1,130 @@ +"""ESAb ATAd + +This is a solution for the Google Code Jam 'ESAb ATAd' problem +Initially, this program reads a single line containing two integers T and B: +the number of test cases and the number of bits in the array, respectively + +The program then asks for each bit of information in the array +with queries to the stdout and readings via stdin + +More information: +https://codingcompetitions.withgoogle.com/ + codejam/round/000000000019fd27/0000000000209a9e +""" + +import sys + +def getBit(index): + print(index) + sys.stdout.flush() + return input() + +def getPair(data, left, b): + """Gets a symmetric pair of bits in the array + + Queries for a symmetric pair of bits and stores the values in data + it also stores if the pair has equal or different values + + Args: + data: list of dicts where local data is being stored + left: index of the left bit of the pair to query + b: length of the data array in the db system + """ + right = b - 1 - left + data[left]['val'] = getBit(left+1) # add 1 because db system indexes from 1 + data[right]['val'] = getBit(right+1) # add 1 because db system indexes from 1 + + # info about different or equal symmetric values are stored in 'sym' property + data[left]['sym'] = data[left]['val'] == data[right]['val'] + data[right]['sym'] = data[left]['sym'] + +def getFluctuationType(data): + # finds the index on the local data array of the first bit + # with a symmetric pair with equal value or None if does not exist such bit + symIndex = next((i for i,v in enumerate(data) if v['sym'] == True), None) + + # finds the index on the local data array of the first bit + # with a symmetric pair with different value or None if does not exist such bit + asymIndex = next((i for i,v in enumerate(data) if v['sym'] == False), None) + + # sym refers to the bit with symmetric pair with equal value + # asym refers to the bit with symmetric pair with different value + + # symB and asymB will store the new values of the known bits after fluctuation + + # dSym and dAsym will store a boolean of wether the known bits changed + # after the fluctuation + + symB = asymB = dSym = dAsym = None + + if symIndex is not None: + symB = getBit(symIndex+1) + dSym = data[symIndex]['val'] != symB + else: + getBit(1) + if asymIndex is not None: + asymB = getBit(asymIndex+1) + dAsym = data[asymIndex]['val'] != asymB + else: + getBit(1) + + if (symB is not None) and (asymB is not None): + if dSym and dAsym: + return "C" + elif (not dSym) and dAsym: + return "R" + elif dSym and (not dAsym): + return "CR" + elif (not dSym) and (not dAsym): + return None + elif (symB is not None) and (asymB is None): + if dSym: + return "C" + else: + return None + elif (symB is None) and (asymB is not None): + if dAsym: + return "C" + else: + return None + +def complement(data): + for d in data: + if d['val'] == '0': + d['val'] = '1' + elif d['val'] == '1': + d['val'] = '0' + +def update(data, fluctuationType): + if fluctuationType == "C": + complement(data) + elif fluctuationType == "R": + data.reverse() + elif fluctuationType == "CR": + complement(data) + data.reverse() + +# reads number of cases t and length of data array +t, b = (int(s) for s in input().split(' ')) +q = 0 # counts how many queries we have made so far + +for testCase in range(1, t + 1): + # creates a list of dicts to store bit values + # and info about wether the bit has a symmetrical pair + # with equal value or not + data = [ {'val': None, 'sym': None } for _ in range(b)] + for i in range(0, int(b/2)): + if q > 0 and q%10 == 0: + update(data, getFluctuationType(data)) + q += 2 + getPair(data, i, b) + q += 2 + r = "" + for dict in data: + r += dict['val'] + print(r) # attempts to give an answer about current bits in the data array + sys.stdout.flush() + ans = input() + q = 0 + if ans != 'Y': + break # if answer was incorrect no more processing is done \ No newline at end of file From cc490f44277ce79de60451586656cd0b627be7c5 Mon Sep 17 00:00:00 2001 From: Aldo Santiago Date: Mon, 13 Feb 2023 19:00:49 -0600 Subject: [PATCH 20/20] docs: ESAb ATAd added readme file --- solutions/esab-atad/README.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 solutions/esab-atad/README.md diff --git a/solutions/esab-atad/README.md b/solutions/esab-atad/README.md new file mode 100644 index 00000000..fd0cac5e --- /dev/null +++ b/solutions/esab-atad/README.md @@ -0,0 +1,16 @@ +# ESAb ATAd + +Last year, a research consortium had some trouble with a distributed database system that sometimes lost pieces of the data. You do not need to read or understand that problem in order to solve this one! + +The consortium has decided that distributed systems are too complicated, so they are storing B bits of important information in a single array on one awesome machine. As an additional layer of security, they have made it difficult to obtain the information quickly; the user must query for a bit position between 1 and B, and then they receive that bit of the stored array as a response. + +Unfortunately, this ultra-modern machine is subject to random quantum fluctuations! Specifically, after every 1st, 11th, 21st, 31st... etc. query is sent, but before the response is given, quantum fluctuation causes exactly one of the following four effects, with equal probability: + +- 25% of the time, the array is complemented: every 0 becomes a 1, and vice versa. +- 25% of the time, the array is reversed: the first bit swaps with the last bit, the second bit swaps with the second-to-last bit, and so on. +- 25% of the time, both of the things above (complementation and reversal) happen to the array. (Notice that the order in which they happen does not matter.) +- 25% of the time, nothing happens to the array. + +Moreover, there is no indication of what effect the quantum fluctuation has had each time. The consortium is now concerned, and it has hired you to get its precious data back, in whatever form it is in! Can you find the entire array, such that your answer is accurate as of the time that you give it? Answering does not count as a query, so if you answer after your 30th query, for example, the array will be the same as it was after your 21st through 30th queries. + +More details: https://codingcompetitions.withgoogle.com/codejam/round/000000000019fd27/0000000000209a9e