Example #1
0
 public void solve(int testNumber, InputReader in, OutputWriter out) {
   int length = in.readInt();
   char[] startState = in.readString().toCharArray();
   int startPosition = in.readInt() - 1;
   char[] endState = in.readString().toCharArray();
   int endPosition = in.readInt() - 1;
   out.printLine("M1");
   for (int i = 0; i < 10; i++) out.printLine("<");
   out.printLine("E");
   for (int i = 0; i < 27; i++) {
     int first = i % 3;
     int second = i / 3 % 3;
     int third = i / 9;
     out.printLine("M" + (100 + i));
     if (first == 1) out.printLine("v");
     else if (first == 2) out.printLine("x");
     out.printLine(">");
     if (second == 1) out.printLine("v");
     else if (second == 2) out.printLine("x");
     out.printLine(">");
     if (third == 1) out.printLine("v");
     else if (third == 2) out.printLine("x");
     out.printLine(">");
     out.printLine("E");
   }
   int position = startPosition;
   while (position >= 10) {
     out.printLine("#1");
     position -= 10;
   }
   while (position > 0) {
     out.printLine("<");
     position--;
   }
   for (int i = 0; i + 3 < length; i += 3) {
     int code = 0;
     for (int j = 2; j >= 0; j--) {
       code *= 3;
       if (startState[j + i] == '.' && endState[j + i] == '-') code++;
       else if (startState[j + i] == '-' && endState[j + i] == '.') code += 2;
     }
     out.printLine("#" + (100 + code));
   }
   int end = (length - 1) - ((length - 1) % 3);
   for (int i = end; i < length; i++) {
     if (startState[i] == '.' && endState[i] == '-') out.printLine("v");
     else if (startState[i] == '-' && endState[i] == '.') out.printLine("x");
     if (i != length - 1) out.printLine(">");
   }
   position = length - 1;
   while (position - endPosition >= 10) {
     out.printLine("#1");
     position -= 10;
   }
   while (position > endPosition) {
     out.printLine("<");
     position--;
   }
   out.printLine("s");
 }
Example #2
0
 public void solve(int testNumber, InputReader in, OutputWriter out) {
   int firstCount = in.readInt();
   int[] first = IOUtils.readIntArray(in, firstCount);
   int secondCount = in.readInt();
   int[] second = IOUtils.readIntArray(in, secondCount);
   int[] countFirst = countDivisors(first);
   int[] countSecond = countDivisors(second);
   Arrays.sort(first);
   Arrays.sort(second);
   long result = 1;
   double doubleResult = 1;
   for (int i = 0; i < primes.length; i++) {
     for (int j = 0; j < Math.min(countFirst[i], countSecond[i]); j++) {
       result *= primes[i];
       result %= MOD;
       doubleResult *= primes[i];
     }
   }
   int firstIndex = 0;
   int secondIndex = 0;
   while (firstIndex < firstCount && secondIndex < secondCount) {
     if (first[firstIndex] == second[secondIndex]) {
       result *= first[firstIndex];
       result %= MOD;
       doubleResult *= first[firstIndex];
       firstIndex++;
       secondIndex++;
     } else if (first[firstIndex] < second[secondIndex]) firstIndex++;
     else secondIndex++;
   }
   if (result == doubleResult) out.printLine(result);
   else out.printFormat("%09d\n", (int) result);
 }
Example #3
0
 public void solve(int testNumber, InputReader in, OutputWriter out) {
   int count = in.readInt();
   int[] computer = IOUtils.readIntArray(in, count);
   int[][] required = new int[count][];
   for (int i = 0; i < count; i++) {
     int requiredCount = in.readInt();
     required[i] = IOUtils.readIntArray(in, requiredCount);
   }
   MiscUtils.decreaseByOne(required);
   int answer = Integer.MAX_VALUE;
   for (int i = 1; i <= 3; i++) answer = Math.min(answer, go(computer, required, i));
   out.printLine(answer);
 }
Example #4
0
 public void solve(int testNumber, InputReader in, OutputWriter out) {
   int count = in.readInt();
   int surprising = in.readInt();
   int required = in.readInt();
   int[] scores = IOUtils.readIntArray(in, count);
   int answer = 0;
   for (int i : scores) {
     if (i < required) continue;
     if (i >= 3 * required - 2) answer++;
     else if (i >= 3 * required - 4 && surprising > 0) {
       answer++;
       surprising--;
     }
   }
   out.printLine("Case #" + testNumber + ":", answer);
 }
Example #5
0
 public void solve(int testNumber, InputReader in, PrintWriter out) {
   int from = in.readInt();
   int to = in.readInt();
   long[] happy = new long[(1 << 11) - 1];
   happy[1] = 4;
   happy[2] = 7;
   int first = 1;
   int last = 3;
   for (int i = 2; i <= 10; i++) {
     for (int j = 0; j < last - first; j++) {
       happy[last + 2 * j] = 10 * happy[first + j] + 4;
       happy[last + 2 * j + 1] = 10 * happy[first + j] + 7;
     }
     int next = last + 2 * (last - first);
     first = last;
     last = next;
   }
   long answer = 0;
   for (int i = 1; i < happy.length; i++)
     answer += Math.max(0, Math.min(happy[i], to) - Math.max(from - 1, happy[i - 1])) * happy[i];
   out.println(answer);
 }
Example #6
0
  public void solve(int testNumber, InputReader in, OutputWriter out) {
    int count = in.readInt();
    int queryCount = in.readInt();
    LongIntervalTree tree =
        new LongIntervalTree(count) {
          @Override
          protected long joinValue(long left, long right) {
            return left + right;
          }

          @Override
          protected long joinDelta(long was, long delta) {
            return was ^ delta;
          }

          @Override
          protected long accumulate(long value, long delta, int length) {
            if (delta == 0) return value;
            return length - value;
          }

          @Override
          protected long neutralValue() {
            return 0;
          }

          @Override
          protected long neutralDelta() {
            return 0;
          }
        };
    for (int i = 0; i < queryCount; i++) {
      int type = in.readInt();
      int from = in.readInt() - 1;
      int to = in.readInt() - 1;
      if (type == 0) tree.update(from, to, 1);
      else out.printLine(tree.query(from, to));
    }
  }
Example #7
0
 public void solve(int testNumber, InputReader in, OutputWriter out) {
   count = in.readInt();
   from = new int[count];
   to = new int[count];
   IOUtils.readIntArrays(in, from, to);
   previousSame = new int[count];
   for (int i = 0; i < count; i++) {
     for (int j = 0; j < i; j++) {
       if (from[i] == from[j] && to[i] == to[j] || from[i] == to[j] && to[i] == from[j])
         previousSame[i] += 1 << j;
     }
   }
   result = new long[8][8][1 << count];
   ArrayUtils.fill(result, -1);
   long answer = 0;
   for (int i = 0; i < count; i++) {
     if (previousSame[i] == 0) {
       answer += go(from[i], to[i], (1 << count) - 1 - (1 << i));
       if (from[i] != to[i]) answer += go(to[i], from[i], (1 << count) - 1 - (1 << i));
     }
   }
   out.printLine(answer);
 }
Example #8
0
 public void solve(int testNumber, InputReader in, PrintWriter out) {
   int stringIndex = in.readInt();
   long letterIndex = in.readLong();
   out.println(go(stringIndex, letterIndex));
 }
Example #9
0
 public void solve(int testNumber, InputReader in, OutputWriter out) {
   int n = in.readInt();
   int m = in.readInt();
   int d = in.readInt();
   int l = in.readInt();
   int[] x = new int[n];
   for (int i = 1; i < n; ++i) x[i] = in.readInt();
   int[] z = new int[m];
   for (int i = 0; i < m; ++i) z[i] = in.readInt();
   int[] p = new int[d];
   int[] r = new int[d];
   for (int i = 0; i < d; ++i) {
     p[i] = in.readInt();
     r[i] = in.readInt();
   }
   int[] interestingCoord = new int[2 * d + 2 * m + n];
   int pos = 0;
   for (int i = 0; i < n; ++i) {
     interestingCoord[pos++] = x[i];
   }
   for (int i = 0; i < m; ++i) {
     interestingCoord[pos++] = z[i] - l;
     interestingCoord[pos++] = z[i] + l;
   }
   for (int i = 0; i < d; ++i) {
     interestingCoord[pos++] = r[i] - l;
     interestingCoord[pos++] = r[i] + l;
   }
   if (pos != interestingCoord.length) throw new RuntimeException();
   Arrays.sort(interestingCoord);
   pos = 0;
   for (int i = 0; i < interestingCoord.length; ++i) {
     if (i == 0 || interestingCoord[i] != interestingCoord[i - 1])
       interestingCoord[pos++] = interestingCoord[i];
   }
   int[] cntGopher = new int[pos];
   boolean[] haveCD = new boolean[pos];
   int[] nextCD = new int[pos + 1];
   int[] prevCD = new int[pos + 1];
   nextCD[pos] = pos;
   prevCD[pos] = pos;
   int[] cntCD = new int[pos];
   for (int i = 0; i < n; ++i) {
     update(cntGopher, decodePos(interestingCoord, pos, x[i]), 1);
   }
   int res = 0;
   for (int i = 0; i < m; ++i) {
     int leftPos = decodePos(interestingCoord, pos, z[i] - l);
     int rightPos = decodePos(interestingCoord, pos, z[i] + l);
     int prevCDPos = getLast(cntCD, haveCD, rightPos);
     if (prevCDPos == -1) prevCDPos = pos;
     int nextCDPos = nextCD[prevCDPos];
     int finalLeft = leftPos;
     int finalRight = rightPos;
     if (prevCDPos != pos) finalLeft = Math.max(finalLeft, prevCDPos + 1);
     if (nextCDPos != pos) {
       int nextCDLeft = decodePos(interestingCoord, pos, interestingCoord[nextCDPos] - 2 * l);
       finalRight = Math.min(finalRight, nextCDLeft - 1);
     }
     if (finalLeft <= finalRight) {
       res += get(cntGopher, finalRight) - get(cntGopher, finalLeft - 1);
     }
     nextCD[rightPos] = nextCDPos;
     prevCD[rightPos] = prevCDPos;
     nextCD[prevCDPos] = rightPos;
     prevCD[nextCDPos] = rightPos;
     if (haveCD[rightPos]) throw new RuntimeException();
     haveCD[rightPos] = true;
     update(cntCD, rightPos, 1);
   }
   out.printLine(res);
   for (int i = 0; i < d; ++i) {
     {
       int leftPos = decodePos(interestingCoord, pos, p[i] - l);
       int rightPos = decodePos(interestingCoord, pos, p[i] + l);
       if (!haveCD[rightPos]) throw new RuntimeException();
       int prevCDPos = prevCD[rightPos];
       int nextCDPos = nextCD[rightPos];
       int finalLeft = leftPos;
       int finalRight = rightPos;
       if (prevCDPos != pos) finalLeft = Math.max(finalLeft, prevCDPos + 1);
       if (nextCDPos != pos) {
         int nextCDLeft = decodePos(interestingCoord, pos, interestingCoord[nextCDPos] - 2 * l);
         finalRight = Math.min(finalRight, nextCDLeft - 1);
       }
       if (finalLeft <= finalRight) {
         res -= get(cntGopher, finalRight) - get(cntGopher, finalLeft - 1);
       }
       nextCD[prevCDPos] = nextCDPos;
       prevCD[nextCDPos] = prevCDPos;
       haveCD[rightPos] = false;
       update(cntCD, rightPos, -1);
     }
     {
       int leftPos = decodePos(interestingCoord, pos, r[i] - l);
       int rightPos = decodePos(interestingCoord, pos, r[i] + l);
       int prevCDPos = getLast(cntCD, haveCD, rightPos);
       if (prevCDPos == -1) prevCDPos = pos;
       int nextCDPos = nextCD[prevCDPos];
       int finalLeft = leftPos;
       int finalRight = rightPos;
       if (prevCDPos != pos) finalLeft = Math.max(finalLeft, prevCDPos + 1);
       if (nextCDPos != pos) {
         int nextCDLeft = decodePos(interestingCoord, pos, interestingCoord[nextCDPos] - 2 * l);
         finalRight = Math.min(finalRight, nextCDLeft - 1);
       }
       if (finalLeft <= finalRight) {
         res += get(cntGopher, finalRight) - get(cntGopher, finalLeft - 1);
       }
       nextCD[rightPos] = nextCDPos;
       prevCD[rightPos] = prevCDPos;
       nextCD[prevCDPos] = rightPos;
       prevCD[nextCDPos] = rightPos;
       if (haveCD[rightPos]) throw new RuntimeException();
       haveCD[rightPos] = true;
       update(cntCD, rightPos, 1);
     }
     out.printLine(res);
   }
 }
Example #10
0
 public void solve(int testNumber, InputReader in, OutputWriter out) {
   out.printLine(answer[in.readInt()]);
 }