I checked them using my AC algorithm

6
100110
000111
-> Impossible

10
1001100110
0101010101
-> 11111111112222222222

10
1001110000
0011111010
-> 11111211221212122222

11
01011100000
01111011001
-> 1111121112121212222222

14
10011111100101
00000110101010
-> 1111121212121111112222222222

18
100111111001010010
000001101010100111
-> 111112121212111111222222222222121112

18
100111111001010011
000001101010100011
-> Impossible

try this one

2 2
1 1 3 2
1 2 3 3
1 2 2 4

1
2

TRY THIS ONE

6 7
1 2 3
2 3 4
3 4 3
1 3 4
4 5 33
5 6 3
4 6 -2

IMPOSSIBLE

Edited by author 27.04.2021 21:36

Edited by author 27.04.2021 21:37

........
.B.B...B
....W...
.B.B.B..
........
.B.B.B..
........
........
ans:1

..W.W...
.B.B.B..
........
.B.B.B..
........
.B.B.B..
........
........
ans:2

..W.W...
.B.B.B..
W.W.W.W.
.B.B.B..
W.W.W.W.
.B.B.B..
..W.W...
........
ans:6

input:

3
1 3 2
2 3 1

output:

1 3 2

" along one of the sides of the playing board" should be removed since it gives the impression that you can only move tiles next to the edges of the board. For more clarity it could say that you can move them parallel to one side of the board, or that you can shift up to four tiles as permitted by the empty square.

2 2
2 2
1 1
6 7
1 7
D U
R U
---
1

3 3
2 3
2 1
2 1 7
1 9 8
7 5 4
L D U
R U R
L L U
-----
8

read(p,q);
  for i:=2 to 10000000 do begin
    a:=i/100*p;
    b:=i/100*q;
    a1:=trunc(a);
    b1:=trunc(b);
    if (b1-a1)>=0.99 then begin
      write(i);
      halt;
    end;
  end;
why WA ?

The limits on the number of hailstones k (1 ≤ k ≤ 100) is not specified.

use sqrt(2.00) instead of 1.41421356

This will make your program accepted. I've tried it.

This probably helps

3 1
0 0
2 2
3 3
1 3

Ans: YES

3 1
0 5
2 5
3 5
1 2

Ans: NO

What can it be?(tests or ideas, something pls)

passes

3
0 1 1
1 2 0
1
1 2

ans:
0

but still WA


Edited by author 20.04.2021 00:52

try this one

input:

3
2 61 62
5 75 20 85 50 61
3 10 20 30
1 5

output:

5

4
3 75 85 20
2 61 62
5 75 20 85 50 61
3 10 20 30
3 30 20 85

Will answer include 75 or not?

My solution in Python 3 took 0.062s and 220 KB. Can it be faster?

just a binary search over overspeeding

object Election1263 extends App {
  val Array(n, m) = scala.io.StdIn.readLine().split(" ").map(_.toInt)
  val list = (0 to m - 1).foldLeft(List.empty[Int]){case (acc, _) =>
    scala.io.StdIn.readLine().split("\n").map(_.toInt).toList match {
      case head :: Nil => acc :+ head
      case _ => acc
    }
  }
  val electionList = list.groupBy(identity).foldLeft(List.empty[Int]) {(s, e) =>
    s :+ e._2.size
  }

  def getPersent(list: List[Int], list1: List[Double]) : List[Double] = list match {
    case head :: tail => getPersent(tail, list1 :+ head * 100.0 / m)
    case head :: Nil => getPersent(Nil, list1 :+ head * 100.0 / m)
    case _ => list1
  }

  val result = getPersent(electionList, List())
  result.foreach(e => println("%.2f".format(e) + "%")
  )
}

#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <stack>
using namespace std;



string solve(string text)
{
    string ts, cs = "", ans = "";
    int i = 0;
    while (i < text.size())
    {

        while(int(text[i]) >= 65 && int(text[i]) <= 122) {
            ts = ""; // create temp string
            ts.push_back(text[i]); // translate char to string
            cs.insert(0, ts); //reverse string
            i++;
        }
        if (i > 0 && int(text[i-1]) >= 65 && int(text[i-1]) <= 122)
        {
            ans += cs; //plus to out ans cypher word
            cs = ""; // make cypher word ""
        }

    ans+=text[i];
    i++;
}
    ans += char(0x20);
    ans += char(0x0a);
    return ans;
}

int main()
{
    string s;
    while(getline(cin, s))
    cout << solve(s);
}