From cba730ec1287b36331a32858504d9059f37f0c09 Mon Sep 17 00:00:00 2001 From: Anand Rai Date: Tue, 23 Oct 2018 20:52:25 +0530 Subject: [PATCH 1/2] codechef smackdown --- src/cc/Bit1.java | 46 +++ src/cc/ChefAndAverageDistance.java | 107 +++++++ src/cc/ChefAndAverageDistance1.java | 67 +++++ src/cc/ChefAndAverageDistance3.java | 67 +++++ src/cc/ChefAndCardTrick.java | 65 +++++ src/cc/ChefAndCardTrick2.java | 50 ++++ src/cc/ChefAndDistance4.java | 54 ++++ src/cc/ChefAndTyping.java | 64 +++++ src/cc/Graph.java | 424 ++++++++++++++++++++++++++++ src/cc/chefAndStrangeAddition.java | 53 ++++ 10 files changed, 997 insertions(+) create mode 100644 src/cc/Bit1.java create mode 100644 src/cc/ChefAndAverageDistance.java create mode 100644 src/cc/ChefAndAverageDistance1.java create mode 100644 src/cc/ChefAndAverageDistance3.java create mode 100644 src/cc/ChefAndCardTrick.java create mode 100644 src/cc/ChefAndCardTrick2.java create mode 100644 src/cc/ChefAndDistance4.java create mode 100644 src/cc/ChefAndTyping.java create mode 100644 src/cc/Graph.java create mode 100644 src/cc/chefAndStrangeAddition.java diff --git a/src/cc/Bit1.java b/src/cc/Bit1.java new file mode 100644 index 0000000..9fd5834 --- /dev/null +++ b/src/cc/Bit1.java @@ -0,0 +1,46 @@ +package cc; + +import java.util.Scanner; + +public class Bit1 { + + public static int findSetBits(int n) { + int rv = 0; + while (n > 0) { + rv += n & 1; + n >>= 1; + } + return rv; + } + + public static void main(String[] args) { + + Scanner scan = new Scanner(System.in); + int t = scan.nextInt(); + while (t > 0) { + --t; + int a = scan.nextInt(); + int b = scan.nextInt(); + int c = scan.nextInt(); + + int num_a_bits = findSetBits(a); + int num_b_bits = findSetBits(b); + + int num_i_bits, num_c_minus_i_bits; + int count = 0; + for (int i = 0; i <= c; ++i) { + num_i_bits = findSetBits(i); + num_c_minus_i_bits = findSetBits(c - i); + + if (num_i_bits == num_a_bits && num_c_minus_i_bits == num_b_bits) { + ++count; + } + } + + System.out.println(count); + + } + scan.close(); + } + +} diff --git a/src/cc/ChefAndAverageDistance.java b/src/cc/ChefAndAverageDistance.java new file mode 100644 index 0000000..189d9e2 --- /dev/null +++ b/src/cc/ChefAndAverageDistance.java @@ -0,0 +1,107 @@ +package cc; + +import java.util.Scanner; + +public class ChefAndAverageDistance { + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int t = scan.nextInt(); +// scan.nextLine(); + while (t > 0) { + --t; + + int n = scan.nextInt(); + int m = scan.nextInt(); + scan.nextLine(); + int[][] grid = new int[n][m]; + int[] arr = new int[m + n - 1]; + int x1, y1; + for (int i = 0; i < n; ++i) { + String str = scan.nextLine(); + for (int j = 0; j < str.length(); ++j) { + grid[i][j] = Integer.parseInt(str.charAt(j) + ""); + } + } + + for (int i = 0; i < grid.length; ++i) { + for (int j = 0; j < grid[i].length; ++j) { + if (grid[i][j] != 1) { + continue; + } + for (int k = 1; k < m + n - 1; ++k) { + for (int l = 1; l <= k; ++l) { + x1 = i + l; + y1 = j + k - l; + + if (x1 < grid.length && y1 < grid[i].length) { + + if (grid[x1][y1] == 1) { + arr[k]++; + } + } + // negative distance + x1 = i - l; + y1 = j + k - l; + + if (x1 < grid.length && y1 < grid[i].length && y1 >= 0 && x1 >= 0) { + if (grid[x1][y1] == 1) { + arr[k]++; + } + } + + x1 = i + l; + y1 = j - k + l; + if (x1 < grid.length && y1 < grid[i].length && y1 >= 0 && x1 >= 0) { + if (grid[x1][y1] == 1) { + arr[k]++; + } + } + + x1 = i - l; + y1 = j - k + l; + if (x1 < grid.length && y1 < grid[i].length && y1 >= 0 && x1 >= 0) { + if (grid[x1][y1] == 1) { + arr[k]++; + } + } + + } + } + + } + } + + for (int i = 1; i < arr.length; ++i) { + arr[i] /= 2; + } + + for (int i = 0; i < grid.length; ++i) { + for (int j = 0; j < grid[i].length; ++j) { + x1 = i + 1; + y1 = j; + if (x1 < grid.length && y1 < grid[i].length) { + if (grid[x1][y1] == 1 && grid[i][j] == 1) + arr[1]++; + } + x1 = i; + y1 = j + 1; + if (x1 < grid.length && y1 < grid[i].length) { + if (grid[x1][y1] == 1 && grid[i][j] == 1) + arr[1]++; + } + } + } + + for (int i = 1; i < arr.length; ++i) { + System.out.print(arr[i] + " "); + } + System.out.println(); + + } + + scan.close(); + + } + +} diff --git a/src/cc/ChefAndAverageDistance1.java b/src/cc/ChefAndAverageDistance1.java new file mode 100644 index 0000000..7856c00 --- /dev/null +++ b/src/cc/ChefAndAverageDistance1.java @@ -0,0 +1,67 @@ +package cc; + +import java.util.Scanner; + +public class ChefAndAverageDistance1 { + + public static int[] arr; + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int t = scan.nextInt(); + while (t > 0) { + --t; + + int n = scan.nextInt(); + int m = scan.nextInt(); + scan.nextLine(); + int[][] grid = new int[n][m]; + arr = new int[m + n - 1]; + for (int i = 0; i < n; ++i) { + String str = scan.nextLine(); + for (int j = 0; j < str.length(); ++j) { + grid[i][j] = Integer.parseInt(str.charAt(j) + ""); + } + } + boolean[][] flag; + for (int i = 0; i < grid.length; ++i) { + for (int j = 0; j < grid[i].length; ++j) { + if (grid[i][j] == 1) { + flag = new boolean[n][m]; + findPath(grid, i, j, 0, flag); + } + } + } + + for (int i = 1; i < arr.length; ++i) { + System.out.print(arr[i] + " "); + } + System.out.println(); + } + + scan.close(); + } + + private static void findPath(int[][] grid, int i, int j, int length, boolean[][] flag) { + if (i >= grid.length || j >= grid[0].length || i < 0 || j < 0 || length >= arr.length) { + return; + } +//-1 represents processed + if (flag[i][j] == true) + return; + + if (grid[i][j] == 1) { + arr[length]+=1; + + } + + flag[i][j] = true; + + findPath(grid, i, j + 1, length + 1, flag); + findPath(grid, i + 1, j, length + 1, flag); + findPath(grid, i, j - 1, length + 1, flag); + findPath(grid, i - 1, j, length + 1, flag); + + } + +} diff --git a/src/cc/ChefAndAverageDistance3.java b/src/cc/ChefAndAverageDistance3.java new file mode 100644 index 0000000..cdf182a --- /dev/null +++ b/src/cc/ChefAndAverageDistance3.java @@ -0,0 +1,67 @@ +package cc; + +import java.util.Scanner; + +public class ChefAndAverageDistance3 { + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int t = scan.nextInt(); + while (t > 0) { + --t; + int n = scan.nextInt(); + int m = scan.nextInt(); + scan.nextLine(); + + int[][] grid = new int[n][m]; + for (int i = 0; i < n; ++i) { + String str = scan.nextLine(); + for (int j = 0; j < str.length(); ++j) { + grid[i][j] = Integer.parseInt(str.charAt(j) + ""); + } + } + + int[] arr = new int[m + n - 1]; + for (int i = 0; i < grid.length; ++i) { + for (int j = 0; j < grid[i].length; ++j) { + if (grid[i][j] == 1) { + boolean[][] grid_t = new boolean[n][m]; + + arr = findPath(grid, grid_t, i, j, 0, arr); + } + } + } + + for (int i = 1; i < arr.length; ++i) { + System.out.print(arr[i] / 2 + " "); + } + System.out.println(); + } + + scan.close(); + } + + private static int[] findPath(int[][] grid, boolean[][] grid_t, int i, int j, int length, int[] arr) { + if (i >= grid.length || j >= grid[0].length || i < 0 || j < 0 || length > arr.length) { + return arr; + } + + // -1 represents processed + if (grid_t[i][j] == true) + return arr; + + if (grid[i][j] == 1) { + arr[length]++; + + } + + grid_t[i][j] = true; + arr = findPath(grid, grid_t, i, j + 1, length + 1, arr); + arr = findPath(grid, grid_t, i + 1, j, length + 1, arr); + arr = findPath(grid, grid_t, i, j - 1, length + 1, arr); + arr = findPath(grid, grid_t, i - 1, j, length + 1, arr); + + return arr; + } + +} \ No newline at end of file diff --git a/src/cc/ChefAndCardTrick.java b/src/cc/ChefAndCardTrick.java new file mode 100644 index 0000000..c60b789 --- /dev/null +++ b/src/cc/ChefAndCardTrick.java @@ -0,0 +1,65 @@ +package cc; + +import java.util.Scanner; + +public class ChefAndCardTrick { + + public static void main(String[] args) { + + Scanner scan = new Scanner(System.in); + + int t = scan.nextInt(); + + while (t > 0) { + --t; + + int n = scan.nextInt(); + + int arr[] = new int[n]; + + for (int i = 0; i < n; ++i) { + arr[i] = scan.nextInt(); + } + + boolean flag = false; + + for (int i = 0; i < n; ++i) { + int j; + for (j = i; j <= i + n; ++j) { + if (arr[j % n] >= arr[(j + 1) % n]) { + break; + } + } + + if (j == i + n - 1) { + flag = true; + break; + } + + } + if (flag) { + System.out.println("YES"); + } else { + System.out.println("NO"); + } + + } + + } + +} +//int count = 0; +//for (int i = 1; i < n - 1; ++i) { +// +// if (arr[i] > arr[i - 1] && arr[i] > arr[i + 1]) { +// ++count; +// } +// if (count == 2) { +// break; +// } +//} +//if (count < 2) { +// System.out.println("YES"); +//} else { +// System.out.println("NO"); +//} \ No newline at end of file diff --git a/src/cc/ChefAndCardTrick2.java b/src/cc/ChefAndCardTrick2.java new file mode 100644 index 0000000..e81b168 --- /dev/null +++ b/src/cc/ChefAndCardTrick2.java @@ -0,0 +1,50 @@ +package cc; + +import java.util.Scanner; + +public class ChefAndCardTrick2 { + + public static void main(String[] args) { + + Scanner scan = new Scanner(System.in); + + int t = scan.nextInt(); + + while (t > 0) { + --t; + + int n = scan.nextInt(); + int[] arr = new int[2 * n]; + + for (int i = 0; i < n; ++i) { + arr[i] = scan.nextInt(); + arr[i + n] = arr[i]; + } + + int count = 1; + int prev = arr[0], curr; + + for (int i = 1; i < arr.length; ++i) { + curr = arr[i]; + if (prev > curr) { + count = 1; + } else { + ++count; + } + prev = curr; + if(count==n) { + break; + } + } + + if (count == n) { + System.out.println("YES"); + } else { + System.out.println("NO"); + } + + } + scan.close(); + } + +} diff --git a/src/cc/ChefAndDistance4.java b/src/cc/ChefAndDistance4.java new file mode 100644 index 0000000..80df532 --- /dev/null +++ b/src/cc/ChefAndDistance4.java @@ -0,0 +1,54 @@ +package cc; + +import java.util.ArrayList; +import java.util.Scanner; + +public class ChefAndDistance4 { + + public static void main(String args[]) { + Scanner scan = new Scanner(System.in); + int t = scan.nextInt(); + while (t > 0) { + --t; + + int n = scan.nextInt(); + int m = scan.nextInt(); + scan.nextLine(); + int[] dist = new int[m + n - 1]; + ArrayList x = new ArrayList<>(); + ArrayList y = new ArrayList<>(); + int v; + for (int i = 0; i < n; ++i) { + String str = scan.nextLine(); + for (int j = 0; j < str.length(); ++j) { + v = Integer.parseInt(str.charAt(j) + ""); + if (v == 1) { + x.add(i); + y.add(j); + } + } + } + int temp; + int x_values[] = new int[x.size()]; + int y_values[] = new int[x.size()]; + + for (int i = x_values.length - 1; x.size() > 0; --i) { + x_values[i] = x.remove(x.size() - 1); + y_values[i] = y.remove(y.size() - 1); + } + + for (int i = 0; i < x_values.length; ++i) { + for (int j = i + 1; j < y_values.length; ++j) { + temp = Math.abs(x_values[i] - x_values[j]) + Math.abs(y_values[i] - y_values[j]); + dist[temp]++; + } + } + + for (int i = 1; i < dist.length; ++i) { + System.out.print(dist[i] + " "); + } + System.out.println(); + } + scan.close(); + } +} diff --git a/src/cc/ChefAndTyping.java b/src/cc/ChefAndTyping.java new file mode 100644 index 0000000..5ae64e9 --- /dev/null +++ b/src/cc/ChefAndTyping.java @@ -0,0 +1,64 @@ +package cc; + +import java.util.HashMap; +import java.util.Scanner; + +public class ChefAndTyping { + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + + int t = scan.nextInt(); + + while (t > 0) { + --t; + + int n = scan.nextInt(); + scan.nextLine(); + + String[] arr = new String[n]; + for (int i = 0; i < n; ++i) { + + arr[i] = scan.nextLine(); + } + + int time = 0; + HashMap map = new HashMap<>(); + + for (int i = 0; i < n; ++i) { + + if (map.containsKey(arr[i])) { + time += map.get(arr[i]) / 2; + continue; + } + + int temp = 0; + for (int j = 0; j < arr[i].length(); ++j) { + if (j == 0) { + temp += 2; + } else { + if (arr[i].charAt(j - 1) == 'd' || arr[i].charAt(j - 1) == 'f') { + if (arr[i].charAt(j) == 'j' || arr[i].charAt(j) == 'k') { + temp += 2; + } else { + temp += 4; + } + } else if (arr[i].charAt(j - 1) == 'j' || arr[i].charAt(j - 1) == 'k') { + if (arr[i].charAt(j) == 'd' || arr[i].charAt(j) == 'f') { + temp += 2; + } else { + temp += 4; + } + } + } + + } + time += temp; + map.put(arr[i], temp); + } + System.out.println(time); + } + scan.close(); + } + +} diff --git a/src/cc/Graph.java b/src/cc/Graph.java new file mode 100644 index 0000000..c394a13 --- /dev/null +++ b/src/cc/Graph.java @@ -0,0 +1,424 @@ +package cc; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedList; + +public class Graph { + private class Vertex { + private HashMap nbrs = new HashMap<>(); + } + + private HashMap vces = new HashMap<>(); + + public int numVertices() { + return vces.size(); + } + + public boolean containsVertex(String vname) { + return vces.containsKey(vname); + } + + public void addVertex(String vname) { + if (this.containsVertex(vname)) { + return; + } + + Vertex vtx = new Vertex(); + vces.put(vname, vtx); + } + + public int numEdges() { + int rv = 0; + + ArrayList vnames = new ArrayList<>(vces.keySet()); + for (String vname : vnames) { + Vertex vtx = vces.get(vname); + rv += vtx.nbrs.size(); + } + + return rv / 2; + } + + // areNbrs(v1, v2) + public boolean containsEdge(String v1name, String v2name) { + Vertex vtx1 = vces.get(v1name); + Vertex vtx2 = vces.get(v2name); + + if (vtx1 == null || vtx2 == null || vtx1.nbrs.containsKey(v2name) == false) { + return false; + } + + return true; + } + + public void addEdge(String v1name, String v2name, int weight) { + Vertex vtx1 = vces.get(v1name); + Vertex vtx2 = vces.get(v2name); + + if (vtx1 == null || vtx2 == null) { + return; + } + + vtx1.nbrs.put(v2name, weight); + vtx2.nbrs.put(v1name, weight); + } + + public void removeEdge(String v1name, String v2name) { + Vertex vtx1 = vces.get(v1name); + Vertex vtx2 = vces.get(v2name); + + if (vtx1 == null || vtx2 == null || vtx1.nbrs.containsKey(v2name) == false) { + return; + } + + vtx1.nbrs.remove(v2name); + vtx2.nbrs.remove(v1name); + } + + public void removeVertex(String vname) { + Vertex v2r = vces.get(vname); + + ArrayList nbrnames = new ArrayList<>(v2r.nbrs.keySet()); + for (String nbrname : nbrnames) { + Vertex nbrvtx = vces.get(nbrname); + nbrvtx.nbrs.remove(vname); + } + + vces.remove(vname); + } + + public void display() { + ArrayList vnames = new ArrayList<>(vces.keySet()); + + for (String vname : vnames) { + String str = vname + " -> "; + + Vertex vtx = vces.get(vname); + ArrayList nbrnames = new ArrayList<>(vtx.nbrs.keySet()); + for (String nbrname : nbrnames) { + str += nbrname + "[" + vtx.nbrs.get(nbrname) + "], "; + } + + System.out.println(str + "."); + } + } + + public boolean hasPath(String v1name, String v2name) { + return hasPathHelper(v1name, v2name, new HashMap<>(), v1name); + } + + private boolean hasPathHelper(String v1name, String v2name, HashMap processed, String psf) { + if (processed.containsKey(v1name) == true) { + return false; + } + processed.put(v1name, true); + + if (this.containsEdge(v1name, v2name) == true) { + System.out.println(psf + v2name); + return true; + } + + Vertex vtx1 = vces.get(v1name); + ArrayList nbrnames = new ArrayList<>(vtx1.nbrs.keySet()); + + boolean mr = false; + for (String nbrname : nbrnames) { + boolean rr = this.hasPathHelper(nbrname, v2name, processed, psf + nbrname); + + if (rr == true) { + mr = true; + } + } + + return mr; + } + + public boolean bfs(String v1name, String v2name) { + LinkedList queue = new LinkedList<>(); + HashMap processed = new HashMap<>(); + + Pair p = new Pair(v1name, v1name); + queue.addLast(p); + + while (queue.size() != 0) { + // 1. Remove and print + Pair rp = queue.removeFirst(); + System.out.println(rp.vname + " via " + rp.psf); + + // 2. check if processed, mark if not + if (processed.containsKey(rp.vname)) { + continue; + } + processed.put(rp.vname, true); + + // 3. check + if (this.containsEdge(rp.vname, v2name)) { + return true; + } + + // 4. add the unprocessed nbrs back + ArrayList nbrnames = new ArrayList<>(vces.get(rp.vname).nbrs.keySet()); + for (String nbrname : nbrnames) { + if (!processed.containsKey(nbrname)) { + Pair np = new Pair(nbrname, rp.psf + nbrname); + queue.addLast(np); + } + } + } + + return false; + } + + public boolean dfs(String v1name, String v2name) { + LinkedList stack = new LinkedList<>(); + HashMap processed = new HashMap<>(); + + Pair p = new Pair(v1name, v1name); + stack.addFirst(p); + + while (stack.size() != 0) { + // 1. Remove and print + Pair rp = stack.removeFirst(); + System.out.println(rp.vname + " via " + rp.psf); + + // 2. check if processed, mark if not + if (processed.containsKey(rp.vname)) { + continue; + } + processed.put(rp.vname, true); + + // 3. check + if (this.containsEdge(rp.vname, v2name)) { + return true; + } + + // 4. add the unprocessed nbrs back + ArrayList nbrnames = new ArrayList<>(vces.get(rp.vname).nbrs.keySet()); + for (String nbrname : nbrnames) { + if (!processed.containsKey(nbrname)) { + Pair np = new Pair(nbrname, rp.psf + nbrname); + stack.addFirst(np); + } + } + } + + return false; + } + + public void dft() { + LinkedList stack = new LinkedList<>(); + HashMap processed = new HashMap<>(); + + ArrayList vnames = new ArrayList<>(vces.keySet()); + for (String vname: vnames) { + if(processed.containsKey(vname)){ + continue; + } + + Pair p = new Pair(vname, vname); + stack.addFirst(p); + + while (stack.size() != 0) { + // 1. Remove and print + Pair rp = stack.removeFirst(); + + // 2. check if processed, mark if not + if (processed.containsKey(rp.vname)) { + continue; + } + processed.put(rp.vname, true); + + System.out.println(rp.vname + " via " + rp.psf); + + // 4. add the unprocessed nbrs back + ArrayList nbrnames = new ArrayList<>(vces.get(rp.vname).nbrs.keySet()); + for (String nbrname : nbrnames) { + if (!processed.containsKey(nbrname)) { + Pair np = new Pair(nbrname, rp.psf + nbrname); + stack.addFirst(np); + } + } + } + } + } + + public void bft() { + LinkedList queue = new LinkedList<>(); + HashMap processed = new HashMap<>(); + + ArrayList vnames = new ArrayList<>(vces.keySet()); + for (String vname: vnames) { + if(processed.containsKey(vname)){ + continue; + } + + Pair p = new Pair(vname, vname); + queue.addLast(p); + + while (queue.size() != 0) { + // 1. Remove and print + Pair rp = queue.removeFirst(); + + // 2. check if processed, mark if not + if (processed.containsKey(rp.vname)) { + continue; + } + processed.put(rp.vname, true); + + System.out.println(rp.vname + " via " + rp.psf); + + // 4. add the unprocessed nbrs back + ArrayList nbrnames = new ArrayList<>(vces.get(rp.vname).nbrs.keySet()); + for (String nbrname : nbrnames) { + if (!processed.containsKey(nbrname)) { + Pair np = new Pair(nbrname, rp.psf + nbrname); + queue.addLast(np); + } + } + } + } + } + + private class Pair { + String vname; + String psf; + + Pair(String vname, String psf) { + this.vname = vname; + this.psf = psf; + } + } + + public boolean IsConnected(){ + LinkedList queue = new LinkedList<>(); + HashMap processed = new HashMap<>(); + int counter = 0; + + ArrayList vnames = new ArrayList<>(vces.keySet()); + for (String vname: vnames) { + if(processed.containsKey(vname)){ + continue; + } + + counter++; + if(counter == 2){ + return false; + } + + Pair p = new Pair(vname, vname); + queue.addLast(p); + + while (queue.size() != 0) { + // 1. Remove and print + Pair rp = queue.removeFirst(); + + // 2. check if processed, mark if not + if (processed.containsKey(rp.vname)) { + continue; + } + processed.put(rp.vname, true); + + System.out.println(rp.vname + " via " + rp.psf); + + // 4. add the unprocessed nbrs back + ArrayList nbrnames = new ArrayList<>(vces.get(rp.vname).nbrs.keySet()); + for (String nbrname : nbrnames) { + if (!processed.containsKey(nbrname)) { + Pair np = new Pair(nbrname, rp.psf + nbrname); + queue.addLast(np); + } + } + } + } + + return true; + } + + public boolean IsCyclic(){ + LinkedList stack = new LinkedList<>(); + HashMap processed = new HashMap<>(); + + ArrayList vnames = new ArrayList<>(vces.keySet()); + for (String vname: vnames) { + if(processed.containsKey(vname)){ + continue; + } + + Pair p = new Pair(vname, vname); + stack.addFirst(p); + + while (stack.size() != 0) { + // 1. Remove and print + Pair rp = stack.removeFirst(); + + // 2. check if processed, mark if not + if (processed.containsKey(rp.vname)) { + return true; + } + processed.put(rp.vname, true); + + System.out.println(rp.vname + " via " + rp.psf); + + // 4. add the unprocessed nbrs back + ArrayList nbrnames = new ArrayList<>(vces.get(rp.vname).nbrs.keySet()); + for (String nbrname : nbrnames) { + if (!processed.containsKey(nbrname)) { + Pair np = new Pair(nbrname, rp.psf + nbrname); + stack.addFirst(np); + } + } + } + } + + return false; + } + + public boolean IsTree(){ + return this.IsConnected() && this.IsCyclic() == false; + } + + public ArrayList gcc(){ + ArrayList rv = new ArrayList<>(); + + LinkedList queue = new LinkedList<>(); + HashMap processed = new HashMap<>(); + + ArrayList vnames = new ArrayList<>(vces.keySet()); + for (String vname: vnames) { + if(processed.containsKey(vname)){ + continue; + } + + Pair p = new Pair(vname, vname); + queue.addLast(p); + + String comp = ""; + while (queue.size() != 0) { + // 1. Remove and print + Pair rp = queue.removeFirst(); + + // 2. check if processed, mark if not + if (processed.containsKey(rp.vname)) { + continue; + } + processed.put(rp.vname, true); + + comp += rp.vname; + + // 4. add the unprocessed nbrs back + ArrayList nbrnames = new ArrayList<>(vces.get(rp.vname).nbrs.keySet()); + for (String nbrname : nbrnames) { + if (!processed.containsKey(nbrname)) { + Pair np = new Pair(nbrname, rp.psf + nbrname); + queue.addLast(np); + } + } + } + + rv.add(comp); + } + + return rv; + } +} diff --git a/src/cc/chefAndStrangeAddition.java b/src/cc/chefAndStrangeAddition.java new file mode 100644 index 0000000..476a2b3 --- /dev/null +++ b/src/cc/chefAndStrangeAddition.java @@ -0,0 +1,53 @@ +package cc; + +import java.util.Scanner; + +public class chefAndStrangeAddition { + public static int findSetBits(int n) { + int rv = 0; + while (n > 0) { + if (bits[n] != 0) { + rv += bits[n]; + break; + } + rv += n & 1; + n >>= 1; + } + + return rv; + } + + public static int[] bits; + + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int t = scan.nextInt(); + while (t > 0) { + --t; + int a = scan.nextInt(); + int b = scan.nextInt(); + int c = scan.nextInt(); + + bits = new int[c + 1]; + for (int i = 0; i <= c; ++i) { + bits[i] = findSetBits(i); + } + + int num_a_bits = bits[a]; + int num_b_bits = bits[b]; + + int count = 0; + for (int i = 0; i <= c; ++i) { + + if (bits[i] == num_a_bits && bits[c - i] == num_b_bits) { + ++count; + } + } + + System.out.println(count); + + } + scan.close(); + } + +} From e0c9d575435f2ec30fba71c6ec46e4259037ca7b Mon Sep 17 00:00:00 2001 From: developersnow <44407719+developersnow@users.noreply.github.com> Date: Tue, 23 Oct 2018 21:24:43 +0530 Subject: [PATCH 2/2] update readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 5c037c2..a8901ad 100644 --- a/README.md +++ b/README.md @@ -3,4 +3,4 @@ This Notebook contains Most frequently used Algorithm and concept used in Compet and some cool functions often used in competitive programming. -All the codes are written in Python3 and Java 8 + the codes are written in Python3 and Java 8