-0.001
-0.002
0

my integer-based output omitted "-" sign in that case

I send program with such procedure:

void moveNorth(double dist)
{
  w += dist / rEarth * 180 / pi;
  if (w > 91.0)
    n = (n - n) / n;
}

And got crash 15, but when i send

void moveNorth(double dist)
{
  w += dist / rEarth * 180 / pi;
}

i got accepted.

So, i think device can reach north pole with test 15 input data, but it's impossible.

The following test helped me:

Input:
17
84 47 44 99 60 43 14 91 8 39 26 15 41 70 90 41 72 48 20 59 3 68 15 21 78 95 5 22 60 61 88 43 59 84 94 19 26 7 61 85 97 86 51 89 55 40 29 78 39 100 89 41 19 3 62 97 98 18 70 9 79 57 51 37 92 96 55 17 55 67 54 3 52 4 92 59 44 20 36 34 72 24 27 90 79
88 38 28 57 7 36 35 16 38 24 7 34 30 76 88 97 29 90 100 32 33 58 27 5 46 61 76 69 87 65 99 26 3 26 34 61 13 69 76 51 92 83 36 73 10 23 69 38 64 69 21 49 78 100 53 23 12 28 92 50 44 42 27 98 20 60 59 32 28 34 82 71 68 17 96 77 91 64 66 7 84 87 55 62 86 59 84 49 86
27 98 29 69 24 27 88 83 37 19 63 22 53 85 90 21 80 18 64 44 84 70 79 22 76 40 59 34
24 7 71 2 4 51 70 27 29 9 61 65 80 23 87 84 8 28 4 87 45 67 82 80 88
61 53 15 100 11 100 75 69 70 77 24 73 98 50 1 59 63 18 38 85 4 73 92 83 76 31 79 95 64 59 34 24 63 49 76 26 100 2 94 70 30 18 42 80 19 94 38 81 11 27 18 14 99 61 48 26 91 27 72 55 37 6
30 99 6 57 24 5 11 18 26 92 87 19 71 57 13 60 38 23 38 55 89 88 15 36 66 58 62 37 64 98 42
45 97 99 54 72 56 64 41 81 55 27 100 78 36 64 37 73 86 27 79 26 14 45 62 79 54 75 16 17 25 9 62 73 60 67 44 15 30 85 47 36 63 98 13 50 61
2 22 99
28 52 24 93 49 37 72 2 12 39 19 36 99 32 8 10 98 3 24 79 39 23 14 54 20 27 3 81 80
77 79 7 80 2 99 28 39 22 30 2 12 100 89 11 31 48 20 80 50 96 58 41 18 23 94 37 1 48 69 80 76 47 38 56 1 89 83 91 10 12 44 22 11 32 84 93 79 55 24 80 50 81 20 19 4 65 56 56 65 76 36 40 75 73 95 75 61 30 17 23 93 60 44 56 43 79 48
73 33 72 52 35 4 24 53 59 40 60 15 4 36 2 96 10 74 42 36 87 71 4 9 64 15 4 19 57 34 18 29 66 41 32 52 45 55 5 55 47 16 69 50 3 70 97 64 96 39 99 34 9 54 42 24 68 97 94 24 30 12 4 47 4 36 99 48 90 55 55 36 70 75
38 25 45 86 88 92 24 39 25 85 92 18 60 60 66 54 35 47 17 39 93 20 26 43 20 15 49 74 3 71 48 92 95 44 29 82 35 53 20
11 89 12 80 48 23 45 53 57 91 69 47
36 89 72 30 8 39 79 33 93 49 80 36 95 24 64 76 10 68 96 73 56 59 52 56 81 49 8 89 91 29 88 78 17 59 8 76 49
38 8 41 38 39 76 32 62 40 7 24 59 54 96 15 12 47 22 44 47 81 85 38 9 72 15 77 30 22 4 79 11 63 71 48 2 99 79 15
90 38 38 48 43 33 62 7 32 35 50 78 16 86 67 76 57 82 5 39 55 8 17 66 71 39 65 72 37 96 86 26 33 76 74 27 8 87 33 91 74 35 21 89 20 87 16 77 68 20 15 23 28 83 40 50 73 4 73 10 99 58 87 83 85 60 10 93 99 94 35 72 28 55 12 48 42 27 76 61 99 42 35 78 24 74 27 96 30 99 57
80 8 44 15 93 55 24 37 53 17 71 76 97 78 39 96 71 18 71 31 16 12 66 93 87 91 71 34 72 69 91 52 76 86 66 20 40 41 56 45 9 79 72 5 56 11 100 26 80 70 8 47 33 73 39 71 16 9 5 87 29 47 38 56 84 55 76 23 95 31 19 4 61 43 8 68 5 60 93 84 29

Output:
G
1 67

is operations of int64(pascal) slower than long long(c++)?

Does anyone know some tests to overcome WA 2?

It's very strange but it seems that even long double precision doesn't enough for this problem. I had function get_x(polyline, y), that calculates x coordinate of polyline on coordinate y. I implemented it through binary searching and then calculating by formula, but that resulted in WA23. Then I made an optimisation: if polyline has integer point with coordinate y: (x, y), I instantly return x.

Edited by author 03.01.2024 20:12

Input:

_123

My first solution output:

_<span class=number>123</span>

My second solution output:

_123

But all passed. So which answer are correct?

Statement is unclear. If you want to solve it you must try all possible interpretations of this statement 'till find the one that the author intended.

You need to have a deep understanding of the bellman-ford algorithm, especially THE RELAXING OPERATION

The idea of problem is pretty interesting. But for me it was implementation hell.

There is a segment whose extension contains the origin

1000 100000000000
99999971585

10 100
86

17 500
476

minimum is  always -1, 1, or 2 ?
1) S = aaaa...aa   => -1        (S = [a]*n)
2) S = aaabaaa   on center different symbol ==> -1 (S = [a]*m + 'b' +[a]*m)
3) S = ababababa...ababa  ==> -1   (S = [ab]*m + 'a' there S is palindrome)
4) S - is not palindrome,  ==> 1
5) S - is palindrome, there at least two different symbols => 2
   Proof 5:
let a = S[1], b = S[i] , and all S[1] = S[2] = ..=S[i-1] = a,  There S is palindrome.
    S = aaaabxy....baaaa
   Take T1 = aaab  T2 = xy...baaaa
   T1 - is not palindrome

    5.1)  T2 also is not palindrome, minimum cut is 2.
    5.2) T2 also palindrome
         5.2.1) i > 2, there two or more 'a' in T1.
           T1 = aaabx   T2 = y....baaaa
          There T1 and T2 both are not palndrome, (think about it).
         5.2.2. i = 2.  T1 = ab  But T2 palindrome, so S = abababababa...aba, this can't be allowed, because S != [ab]*m + 'a'  already checked.

What may cause this judgement result?

import sys, math

numbers = []
empty_lines = 0

for line in sys.stdin:
    line = line.strip()

    if line == "":
        empty_lines += 1
        if empty_lines == 2:
            break
    else:
        empty_lines = 0
        numbers.extend(line.split())

for num in reversed(numbers):
    print(f"{math.sqrt(int(num)):.4f}")

Don't know why so many authors have posted 2*n-1.. That's obviously a wrong solution...

Just think about if the stone is in the odd and the man touches the odd, things will be done smoothly.

n=2

var
  i,n,l,j:longword; found:boolean;
begin
  readln(n);
  repeat
  found:=False;
  for j:=3 to n div 2 do
  begin
    if n mod j=0 then
    begin
      found:=True;
      break;
    end;
  end;
  if found then n:=j;
  until not found;
  writeln(n-1);
  readln;
end.

Please help me to optimize my code. It's 0.405 sec