There were mentioned, that it is required 64-bit integer type. I also add, that it has to be unsigned, otherwise you get WA 8.

Can somebody give me anti-greedy tests so that a greedy solution will not give correct answer? A test like #39? I'm sure that greedy is the right solution, i cannot find counter-test for my solution.

Guess, why I had wasted 18 attempts?
The exponent can have + sign: 1.3e+32

All bad wished to author.

#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    int n, a, razn, k1 = 0, k2 = 0;
    cin >> n;
    vector<int>num;
    for (int i = 0; i < n; i++) {
        cin >> a;
        num.push_back(a);
    }
    sort(num.begin(), num.end());
    int kol = 0;
    for (int i = 0; i < n - 1; i++) {//все камни кроме максимума
        kol += num[i];
    }
    if (kol < num.back()) {//если все камни меньше самого максимального
        cout << num.back() - kol;
    }
    else if (kol == num.back()) {//если все камни pавны максимальному
        cout << 0;
    }
    else if (kol > num.back()) {//если все камни больше максимального
        k2 = num.back();
        for(int i =n-2;i>=0;i--){
            if (k1 < k2) {
                k1 += num[i];
            }
            else if (k1 > k2) {
                k2 += num[i];
            }
            else if (k1 == k2) {
                k1 = num[i];
                k2 = 0;
            }
        }
        cout << abs(k1 - k2);
    }
}

//my program is fine solves any of my values. what is in test 5?

n, m = map(int, input().split())
a = []
b = [1]
c = []
for i in range(m):
    f = int(input())
    a.append(f)
a = sorted(a)
f = 0
for i in range(1, len(a)):
    if a[i] == a[i - 1]:
       b[f] += 1
    elif a[i] != a[i - 1]:
        b.append(1)
        f += 1
for i in range(len(b)):
    b[i] = float(b[i] / m * 100)
for i in range(len(b)):
    c.append('%.2f' % b[i] + '%')
for i in range(n):
    try:
        print(c[i])
    except:
        print('0.00%')

If my teacher is watching this post, sorry.

Bruteforcing length gives WA, bruteforcing angle gives AC

I checked several times and everything is working correctly, help me


def encryption(txt):
    cipher = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}


    encryption_list = []
    for i in txt:
        encryption_list.append(cipher[i])

    c = d = c1 = 0
    encryption_last_list = []
    for i in encryption_list:
        if d == 0:
            d += 1
            c = i
            i -= 5

            if i < 0:
                i = 25 - abs(i)
            encryption_last_list.append(i)

        else:
            c1 = i
            i -= c
            c = c1
            if i < 0:
                i = 26 - abs(i)
            encryption_last_list.append(i)

    decodding_list = []
    for i in encryption_last_list:
        for k, v in cipher.items():
            if v == i:
                decodding_list.append(k)

    return decodding_list

text = input()
if len(text) <= 99:
    c = ''
    output = encryption(text.lower())
    for i in output:
        c += i
    print(c)

can anyone please explain the solution which uses the coordinates i think ...

Edited by author 24.01.2023 20:46

Edited by author 24.01.2023 20:46

Edited by author 24.01.2023 20:46

I get WA 1 with calculating distance in this way
for(int i=0;i<len;i++)
            {
                ans+=pow(((int)(buf[i]-'0')),3);
            }
while accepted in this way
 for(int i=0;i<len;i++)
            {
                ans+=(buf[i]-'0')*(buf[i]-'0')*(buf[i]-'0');
            }
WHY?!!!!
Is this a bug on judge or bug in function?!!
the compiler is g++

Notice, that +1 and -1 mean not victory and defeat states.

INPUT
2
L 1 +1

OUTPUT
+1

4 3
1 2
2 3
3 4

Luck is possible

be attentive with loop (while)! we know formule n - x * k =) and in depends of number parity condition will be >= (ex. [n - x * k >= n mod k] or [n - x * k >= k]). Good luck!)

Edited by author 19.01.2023 16:23

Can anyone check if I missed any scenario ?

1, 2, 3, 4, 5 => Nothing to do here"
5, 4, 3, 2, 1 => Nothing to do here"
5, 2, 3, 4, 1 => "Yes\n1 5"
1, 8, 3, 4, 5, 6, 7, 2, 9 => "Yes\n2 8"
1, 8, 7, 6, 5, 4, 3, 2, 9 => "Yes\n1 9"
9, 8, 3, 6, 5, 4, 7, 2, 1 => "Yes\n3 7"
1 => Nothing to do here"
1, 1, 1, 1, 1 => "Nothing to do here"
9, 2, 3, 5, 4, 6, 7, 8, 1 => "No hope"
1, 2, 3, 9, 5, 6, 7 => "No hope"
7, 6, 5, 9, 3, 2, 1 => "No hope"
1, 1 => "Nothing to do here"
1, 2 => "Nothing to do here"
1, 2, 4, 3, 5, 6 => "Yes\n3 4"
6, 5, 3, 4, 2, 1 => "Yes\n3 4"
2, 1, 3 => "Yes\n1 2"
1, 3, 2 => "Yes\n2 3"
1, 2, 3, 2, 3, 4, 5 => "Yes\n3 4"
1, 5, 7, 2, 4, 5 => "No hope"

WA-3:
1 2 3
.#
#.
..
1 1 1
1 1 3
-----
NO

WA-12:
3 3 3
.#.
...
...
..#
...
..#
...
...
...
1 2 2
3 3 3
-----
YES
2
climb east
jump south

Interesting that test48, test70 (with reservations) and test80 do not look so hard to my solution. At least if the commenters in previous threads were right with examples of these tests. But mysterious test30 and test31 - I don't even imagine what structure they got.

Test70 is "randomly" solvable: with time distributed between 0.3 and 2.9 seconds (with avg = 1.1 sec) on my Intel i5-9400 (by "randomly" - I mean, of course, that could be 2.9 seconds which is TLE and would not pass)

And my suggestion: It would be nice to have a separate section on the site with parallel running of tests for such hard computational tasks. I mean: maybe someone also passes test 70, but fails test 30, for example. And the total percentage: passed N tests, failed tests with numbers K, L, M

In this task you need to divide by 9. I wrote blog about this: https://codeforces.com/blog/andreyDagger

..................................................
.......................┌──────┐...................
.......................│......│...................
.......................│......│...................
.......................│......│...................
.......................│......│...................
.......................│......│...................
┌────────┐.............│......│...................
│........│.............└──────┘...................
│........│........................................
│........│........................................
│─────┐..│........................................
│.....│..│........................................
│.....│..│........................................
│.....│..│..............┌──┐......................
│.....│..│..............│..│......................
└────────┘..............│..│......................
└─────┘.................└──┘......................
..................................................
..................................................



.................................┌┐...............
.................................└┘...............
..┌──────┐.................................┌─────┐
..│......│........┌────────┐...............│.....│
..│......│........│........│...............│.....│
..│......│........│........│...┌───┐.......│.....│
..│.┌───┐│........│........│...│...│.......│.....│
..│.│┌──││───┐....│........│..┌│──┐│.......│.....│
..│.││..││...│....│........│..││..││.......└─────┘
.┌└─│───│┘┐..│....│........│..┌─┐──┘..............
.┌──└───┘.│..│....│........│..│.│.│...............
.│...││...│..│┌─────┐......│..└─┘─┘...............
.│...││...│..││...└─│──────┘...┌───┐..............
.│...││...│..││.....│..........│...│..............
.│...││...│..││.....│..........│...│..............
.└────┘──────┘│.....│........┌───┐.│..............
.│........│...│.....│........│.└─│─┘..............
.│........│...└─────┘........│..┌│................
.└────────┘..................│..└│................
.............................└───┘................



..................................................
..................................................
..................................................
..................................................
..................................................
..................................................
..........┌─┐─┌─┐.................................
..........│.│.│.│.................................
..........┌─────┐.................................
..........│.....│.................................
..........│.....│.................................
..........│.....│.....................┌┌┐.........
..........│.....│.....................┌┐┐.........
..........│.....│.....................└┘┘.........
..........└─────┘.................................
..................................................
..................................................
..................................................
..................................................
..................................................



..................................................
..┌┐..............................................
..└┌┐┌┐...........................................
...└┌└┘...........................................
....└┘............................................
..................................................
..................................................
...............................┌┌┌┐┐┐.............
...............................└└└┘┘┘.............
.....┌───┐........................................
.....│┘─└│........................................
.....││.││........................................
.....│┐─┌│........................................
.....└───┘........................................
..................................................
..................................................
..................................................
..................................................
..................................................
..................................................



┌┌──┌┌──┐────┐┐───┌┐─┌───────┐─┌─────┌──┐┐───┌───┐
┌│──│││││─│──│──┌─────────┐───┐┌────┐─┐┌││┐││││┐┐│
│││││││┌│────│──┌────┐─┘──││││││┌─────────┐──││──│
││┌┌│└──┘─│─┌│┐─││││││││││││┌─│││││─││││┘│││─││─││
│┌──┌──┐──┘─┌───│──┐─│─┐──│┌───││┐│┐│─│───│┌─────┐
└│──││││││┌─│││─││┐│─│┐│└┌││──┘│││──││││││││──┘│││
└│──│──││─│┌────│──┐││││┌┐│││┌─└│───┘│││┌─││─────│
┌│││└──┘┌─└│││──└────┘││└┘│││││┌││└─│─│┘│─││────┘│
┌│┐││─┐│││││││││││││┌─┐│──││─│││││─┐││││││││││││││
│││─└──────││┘│┌│││││─││─┌││└│└─││──│─┘│││││─┐│┘││
└└─────││││││─│└││││└─┘│──│└────│┘││││─││┘│└─────┘
│││││││││─││└──────│──────┘└─│──│──┌│───┌──────┐─│
└─┘┌│┌─└│──│─────┌─│──┐│───┘┌└─┌└───────│─┘│┘│││││
││└││││││└└│──┐──│─│──│┘─│└──│─│││││││─│││││─┌││─┐
││┌─│┌──│─┐└───────┘││││││─│││┌│┐│││││││││││─└││││
┌──┐││┘││││││─┌┐││─│││││┌┐─││││││││││──┘││───│││─│
││└│└───└──└──└┘─│─└──││└┘──││└│┘│││││─┘│└────┘│││
│└└│─│┘─│││││──││└────┘│─┘─││└─└───└────│──┘┌└─│─┘
└──┘─│└─││││└───│──│──┘│────│─┘│─└─┘──┘─└──────┘─┘
└────└────┘└────└──────┘────└──────┘┘┘───└┘─┘─┘┘└┘

Edited by author 08.09.2019 16:59

Edited by author 08.09.2019 17:01

Edited by author 08.09.2019 17:01

Edited by author 08.09.2019 17:06

Edited by author 08.09.2019 17:06

Edited by author 08.09.2019 17:07

Edited by author 08.09.2019 17:07

Edited by author 08.09.2019 17:15

#include <stdio.h>

#define maxn 1000001
        long n;
       short result[31],b[maxn];
       int tr[maxn];
      long count,i,j;

main()
{
       scanf("%ld",&n);
      for (i=0;i<n;i++) b[i]=0;
      b[1%n]=1;
      tr[1%n]=0;
      if (n!=1) b[2%n]=2;
      tr[2%n]=0;
      count=1;
       while (b[0]==0 && count <30)
      {
          count++;
          for (i=1;i<n;i++)
         if  (b[i]!=0)
         {
             if (b[(i*10+1)%n]==0)
            {
                b[(i*10+1)%n]=1;
               tr[(i*10+1)%n]=i;
            };
             if (b[(i*10+2)%n]==0)
            {
                b[(i*10+2)%n]=2;
               tr[(i*10+2)%n]=i;
            };
         }
      }
      if (b[0]==0)
      {
          printf("Impossible");
      }
      else
      {
          i=0;
         j=1;
         result[j]=b[i];
         while (tr[i]!=0)
         {
             i=tr[i];
            j++;
            result[j]=b[i];
         }
         for (i=j;i>0;i--) printf("%d",result[i]);
      }
    getchar();
}

var
  f,q,be:array[0..1000] of integer;
  n,x,a,b,c:integer;
  m:char;
begin
{assign(input,'1282.txt');
reset(input);
}  readln(n);
  for x:=1 to n do
    be[x]:=-3;
  for x:=2 to n do
    begin
      read(m);
      if m='L' then
        begin
          readln(a,b);
          if be[a]=-3 then
            begin
              inc(c);
              q[c]:=a;
              be[a]:=-1;
            end;
          if b=-1 then be[a]:=1;
          if (b=0) and (be[a]<0) then be[a]:=0;
        end
      else
        readln(f[x]);
    end;
  b:=1;
  while q[b]<>1 do
    begin
      if be[f[q[b]]]<-2 then
        begin
          inc(c);
          q[c]:=f[q[b]];
          be[f[q[b]]]:=-1;
        end;
      if be[q[b]]=-1 then be[f[q[b]]]:=1;
      if (be[q[b]]=0) and (be[f[q[b]]]<0) then be[f[q[b]]]:=0;
      inc(b);
    end;
  if be[1]=1 then writeln('+1') else writeln(be[1]);
end.
{be[n]==the best value it then player play best
f[n]==the father of n
be[n]=-3===>it hasn't been visited
}