pushing lots of code

Author: gkcs

Blogs/MyJourney

@@ -11,8 +11,8 @@
  </content>
  <orderEntry type="inheritedJdk" />
  <orderEntry type="sourceFolder" forTests="false" />
+ <orderEntry type="library" name="chelper" level="project" />
  <orderEntry type="library" name="Maven: junit:junit:4.12" level="project" />
  <orderEntry type="library" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
- <orderEntry type="library" name="chelper" level="project" />
  </component>
 </module>

Competitive Programming.iml

@@ -0,0 +1,18 @@
+package main.java;
+
+public class MaxSumArray {
+ public static void main(String[] args) {
+ int n = 10;
+ int a[] = new int[]{-1, -3, -7, -1, -10, -2, -3, -2, -1, -3};
+ int max_sum = Integer.MIN_VALUE, current_sum = 0;
+ for (int i = 0; i < n; i++) {
+ current_sum = current_sum + a[i];
+ if (current_sum < 0) {
+ current_sum = a[i];
+ }
+ max_sum = Math.max(current_sum, max_sum);
+ System.out.print(max_sum + " ");
+ }
+ System.out.println("\n" + max_sum);
+ }
+}

src/main/java/main/java/BruteForceSolver.java

@@ -7,33 +7,54 @@
 
 public class Solution {
  public static void main(String[] args) throws IOException {
- final BufferedReader inputReader = new BufferedReader(new InputStreamReader(System.in));
- final StringBuilder stringBuilder = new StringBuilder();
- final int t = 1;
- final Solution solution = new Solution();
- for (int test = 0; test < t; test++) {
- final long a[] = new long[Integer.parseInt(inputReader.readLine())];
- final String[] split = inputReader.readLine().split(" ");
- for (int i = 0; i < split.length; i++) {
- a[i] = Integer.parseInt(split[i]);
+ int n = 5, m = 5;
+ int matrix[][] = new int[n][m];
+ int sum[][] = new int[n][m];
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ matrix[i][j] = i * n + j + 1;
+ int sumOfPreviousColumn;
+ if (j == 0)
+ sumOfPreviousColumn = 0;
+ else
+ sumOfPreviousColumn = sum[i][j - 1];
+ int sumOfPreviousRow;
+ if (i == 0)
+ sumOfPreviousRow = 0;
+ else
+ sumOfPreviousRow = sum[i - 1][j];
+ int sumOfDiagonal;
+ if (i == 0 || j == 0) {
+ sumOfDiagonal = 0;
+ } else {
+ sumOfDiagonal = sum[i - 1][j - 1];
+ }
+ sum[i][j] = matrix[i][j]
+ + sumOfPreviousColumn
+ + sumOfPreviousRow
+ - sumOfDiagonal;
  }
- stringBuilder.append(solution.getAnswer(a)).append('\n');
  }
- System.out.println(stringBuilder);
- }
-
- public long getAnswer(final long[] a) {
- Arrays.sort(a);
- final long powersOf2[] = new long[a.length];
- final long mod = 1000000007;
- powersOf2[0] = 1;
- for (int i = 1; i < a.length; i++) {
- powersOf2[i] = (powersOf2[i - 1] << 1) % mod;
+ for (int i = 0; i < n; i++) {
+ System.out.println(Arrays.toString(matrix[i]));
+ }
+ System.out.println();
+ System.out.println();
+ for (int i = 0; i < n; i++) {
+ System.out.println(Arrays.toString(sum[i]));
  }
- long ans = 0;
- for (int i = 0; i < a.length; i++) {
- ans = (ans + (powersOf2[i] - powersOf2[a.length - i - 1]) * a[i]) % mod;
+ BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+ String s = reader.readLine();
+ while (!s.equalsIgnoreCase("Quit")) {
+ int r1 = Integer.parseInt(reader.readLine()) - 1,
+ r2 = Integer.parseInt(reader.readLine()) - 1,
+ c1 = Integer.parseInt(reader.readLine()) - 1,
+ c2 = Integer.parseInt(reader.readLine()) - 1;
+ System.out.println(sum[r2][c2]
+ - sum[r1 - 1][c2]
+ - sum[r2][c1 - 1]
+ + sum[r1 - 1][c1 - 1]);
+ s = reader.readLine();
  }
- return ans;
  }
 }

src/main/java/main/java/MaxSumArray.java

@@ -0,0 +1,25 @@
+package main.java.codechef;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import static java.lang.Integer.parseInt;
+
+public class BalancedGame {
+ public static void main(String[] args) throws IOException {
+ final BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
+ final StringBuilder stringBuilder = new StringBuilder();
+ for (int t = parseInt(bufferedReader.readLine()); t > 0; t--) {
+ String line[] = bufferedReader.readLine().split(" ");
+ final int n = parseInt(line[0]), cMax = parseInt(line[1]), hMax = parseInt(line[2]);
+ final long seeds[][] = new long[2][n];
+ for (int i = 0; i < n; i++) {
+ line = bufferedReader.readLine().split(" ");
+ seeds[1][i] = Long.parseLong(line[0]);
+ seeds[2][i] = Long.parseLong(line[1]);
+ }
+ }
+ System.out.print(stringBuilder);
+ }
+}

src/main/java/main/java/Solution.java

@@ -0,0 +1,96 @@
+package main.java.codechef;
+
+import java.util.Arrays;
+import java.util.Random;
+
+public class BruteForceSolver {
+ private final int[][][] w;
+ private final int[] starts;
+ private final int[] ends;
+ private final int[][] cycleLengths;
+
+ public BruteForceSolver(int n, int[][] weights, final int[] cycleWeights, final int[] starts, int[] ends) {
+ w = getWeights(weights, n);
+ cycleLengths = getCycleLengths(n, w, cycleWeights, starts, ends);
+ this.starts = starts;
+ this.ends = ends;
+ }
+
+ public static void main(String[] args) {
+ final Random random = new Random();
+ int n = random.nextInt(20) + 1;
+ int a[] = new int[n];
+ int[][] weights = new int[n][];
+ int[] starts = new int[n];
+ int[] ends = new int[n];
+ int[] cycleWeights = new int[n];
+ for (int i = 0; i < n; i++) {
+ a[i] = random.nextInt(20) + 1;
+ weights[i] = new int[a[i]];
+ for (int j = 0; j < a[i]; j++) {
+ weights[i][j] = random.nextInt(20) + 1;
+ }
+ starts[i] = random.nextInt(a[i]);
+ ends[i] = random.nextInt(a[i]);
+ cycleWeights[i] = random.nextInt(20) + 1;
+ }
+ }
+
+ public int solve(int v1, int v2, int c1, int c2) {
+ if (c1 > c2) {
+ int temp = v1;
+ v1 = v2;
+ v2 = temp;
+ temp = c1;
+ c1 = c2;
+ c2 = temp;
+ }
+ final int cycleDistance1 = Math.abs(cycleLengths[c1][0] - cycleLengths[c2][0]),
+ excess = findDistance(starts[c1], ends[c1], w[c1]),
+ first1 = findDistance(v1, ends[c1], w[c1]),
+ second1 = findDistance(starts[c2], v2, w[c2]);
+ final int cycleDistance2 = Math.abs(cycleLengths[c1][1] - cycleLengths[c2][1]),
+ first2 = findDistance(v1, starts[c1], w[c1]),
+ second2 = findDistance(ends[c2], v2, w[c2]);
+ final int possibilityOne = cycleDistance1 - excess + first1 + second1;
+ final int possibilityTwo = cycleDistance2 - excess + first2 + second2;
+ return Math.min(possibilityOne, possibilityTwo);
+ }
+
+ public int[][] getCycleLengths(final int n, final int[][][] w, final int[] cycleWeights, final int[] starts, final int[] ends) {
+ final int[][] lengths = new int[n][2];
+ final int[] distances = new int[n];
+ for (int i = 0; i < n; i++) {
+ distances[i] = findDistance(starts[i], ends[i], w[i]);
+ }
+ for (int j = 1; j < n; j++) {
+ lengths[j][0] = lengths[j - 1][0] + distances[j - 1] + cycleWeights[j - 1];
+ }
+ for (int j = n - 1; j > 0; j--) {
+ lengths[j][1] = lengths[(j + 1) % n][1] + distances[(j + 1) % n] + cycleWeights[j];
+ }
+ return lengths;
+ }
+
+ public int[][][] getWeights(final int weights[][], final int n) {
+ final int w[][][] = new int[n][][];
+ for (int i = 0; i < n; i++) {
+ final int size = weights[i].length;
+ w[i] = new int[size][2];
+ for (int j = 1; j < size; j++) {
+ w[i][j][0] = w[i][j - 1][0] + weights[i][j - 1];
+ }
+ w[i][size - 1][1] = weights[i][size - 1];
+ for (int j = size - 2; j > 0; j--) {
+ w[i][j][1] = w[i][j + 1][1] + weights[i][j];
+ }
+ }
+ return w;
+ }
+
+ private int findDistance(final int start, final int end, final int[][] weights) {
+ final int clockwise = Math.abs(weights[start][0] - weights[end][0]);
+ final int antiClockwise = weights[weights.length - 1][1] + weights[weights.length - 1][0] - clockwise;
+ return clockwise > antiClockwise ? antiClockwise : clockwise;
+ }
+}