Datasets:

verifiers-for-code

/

CodeNet-24K

like 5

Print the number of different kinds of colors of the paint cans. * * *

s198894864

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

a,b,c = map(int.input().split()) if a=b=c: print(1) elif (a=b or b=c or a=c): print(2) else: print(3)

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s207895275

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

cols = map( int, input().split() ) cols set = set( cols ) print( len( cols set ) )

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s386071531

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

a,b,c = int(input().split()) if a=b=c: print(1) elif (a=b or b=c or a=c): print(2) else: print(3)

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s303029683

Wrong Answer

p03962

The input is given from Standard Input in the following format: a b c

i = list(map(int, input().split())) i.sort() a = 0 for k in range(len(i)): if i[k] != i[k - 1]: a += 1 print(a)

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s717435309

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

cols = list( int, input().split() ) num col = cols.unique(); print( num col )

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s163426428

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

a,b.c=map(int,input().split()) L=[a,b,c] L.sort() if L[0]==L[2]: print(1) elif　L[0]<L[1]<L[2]: print(3) else: print(2)

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s586022005

Accepted

p03962

The input is given from Standard Input in the following format: a b c

A = sorted(list(map(int, input().split()))) print(4 - A.count(A[1]))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s335590784

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

a = list(map(int, input().split()) a = list(set(a)) print(len(a))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s063257187

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

a,b,c = map(int,input().split()) print(len(set{a,b,c}))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s957183008

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

a=list(map(int,input().split()) return len(set(a))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s005250152

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

abc = list(map(int, input().split())) print(len(set(abc))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s302132476

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

int(input(a, b, c)) set(pennki) = (a, b, c) len(set(pennki))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s692922268

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

n, c = list(map(int, input().split())) print(c * ((c - 1) ** (n - 1)))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s295198000

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

a = int(input().split()) print(len(list(set(a)))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

Print the number of different kinds of colors of the paint cans. * * *

s934756180

Runtime Error

p03962

The input is given from Standard Input in the following format: a b c

a = [int(i) for i in input().split()] print(len(set(a))

Statement AtCoDeer the deer recently bought three paint cans. The color of the one he bought two days ago is a, the color of the one he bought yesterday is b, and the color of the one he bought today is c. Here, the color of each paint can is represented by an integer between 1 and 100, inclusive. Since he is forgetful, he might have bought more than one paint can in the same color. Count the number of different kinds of colors of these paint cans and tell him.

[{"input": "3 1 4", "output": "3\n \n\nThree different colors: 1, 3, and 4.\n\n* * *"}, {"input": "3 3 33", "output": "2\n \n\nTwo different colors: 3 and 33."}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s830518682

Accepted

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

# coding: utf-8 import sys from collections import deque sr = lambda: sys.stdin.readline().rstrip() ir = lambda: int(sr()) lr = lambda: list(map(int, sr().split())) def main(): N = ir() P = lr() P = [((p - 1) // N, (p - 1) % N) for p in P] dp = [[min(i, N - 1 - i, j, N - 1 - j) for j in range(N)] for i in range(N)] people = [[True] * N for i in range(N)] answer = 0 for i, j in P: answer += dp[i][j] people[i][j] = False que = deque([(i, j, dp[i][j])]) popleft = que.popleft append = que.append while que: y, x, cur = popleft() cur += people[y][x] if x > 0: if dp[y][x - 1] > cur: dp[y][x - 1] = cur append((y, x - 1, cur)) if x < N - 1: if dp[y][x + 1] > cur: dp[y][x + 1] = cur append((y, x + 1, cur)) if y > 0: if dp[y - 1][x] > cur: dp[y - 1][x] = cur append((y - 1, x, cur)) if y < N - 1: if dp[y + 1][x] > cur: dp[y + 1][x] = cur append((y + 1, x, cur)) print(answer) if __name__ == "__main__": main()

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s914719850

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

# -*- coding: utf-8 -*- import sys buff_readline = sys.stdin.buffer.readline def read_int(): return tuple(buff_readline()) def read_int_n(): return tuple(map(int, buff_readline().split())) def slv(N, P): M = N + 2 cost = [0] * M**2 occupy = [True] * M**2 for i in range(N): im = i * (M + 1) for j in range(N): cost[im + j + 1] = min(i, j, N - i - 1, N - j - 1) ds = [-1, 1, -M, M] ans = 0 for p in P: p -= 1 x = p // N y = p % N p = x * M + y + M + 1 ans += cost[p] occupy[p] = False s = [p] while s: pi = s.pop() for d in ds: ni = pi + d nc = cost[pi] + (1 if occupy[pi] else 0) if nc < cost[ni]: s.append(ni) cost[ni] = nc return ans def main(): # N = read_int() # P = read_int_n() # print(slv(N, P)) import random N = 500 P = list(range(1, N**2 + 1)) random.shuffle(P) print(slv(N, P)) if __name__ == "__main__": main()

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s157645620

Runtime Error

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

#!/usr/bin/env python3 n = int(input()) numbers = input().split(" ") r = 0 p = [] hate = [-1] * (n * n) is_seated = [1] * (n * n) def is_area(x, y): if x >= 0 and x < n and y >= 0 and y < n: return True else: return False def rewrite(x, y): global hate global is_seated global n # print("b") # print(x, y) index = (x) * n + (y) # if hate[index] == -1: # print("error") # print(x, y) # print("-------") points = [[x - 1, y - 1], [x - 1, y + 1], [x + 1, y - 1], [x + 1, y + 1]] flag = 0 for point in points: if is_area(point[0], point[1]): new_index = point[0] * n + point[1] if ( hate[new_index] == -1 or hate[new_index] > is_seated[index] + hate[index] ): hate[new_index] = is_seated[index] + hate[index] rewrite(point[0], point[1]) else: flag += 1 if flag == 4: return for x in numbers: p.append(int(x)) for i in range(n): hate[i] = 0 hate[n * n - n + i] = 0 hate[i * n] = 0 hate[i * n + n - 1] = 0 for k in p: for i in range(n): for j in range(n): # if hate[i * n + j] == -1: # print("error") rewrite(i, j) r += hate[k - 1] is_seated[k - 1] = 0 # for i in range(n): # for j in range(n): # print(hate[i * n + j], end = "") # print() print(r)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s473374676

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

import sys from collections import deque # from numba import jit input_methods = ["clipboard", "file", "key"] using_method = 0 input_method = input_methods[using_method] tin = lambda: map(int, input().split()) lin = lambda: list(map(int, input().split())) mod = 1000000007 # +++++ # @jit def gg(nn, x, y, n, is_sit, cc, av): q = deque() q.append(1000 * x + y) while q: v = q.popleft() x, y = v // 1000, v % 1000 nn[x][y] -= 1 k = nn[x][y] cc[x][y] = av for dx, dy in ([-1, 0], [0, -1], [1, 0], [0, 1]): if x + dx < 0 or x + dx >= n or y + dy < 0 or y + dy >= n: continue if nn[x + dx][y + dy] <= k + is_sit[x + dx][y + dy]: continue if cc[x + dx][y + dy] == av: continue q.append((x + dx) * 1000 + (y + dy)) cc[x + dx][y + dy] = av # print('yyyyyy') # for l,ll in zip(nn,cc): # print(l,ll) def main(): n = int(input()) nn = [[(n + 1) // 2] * n for _ in range(n)] is_sit = [[1] * n for _ in range(n)] cc = [[0] * n for _ in range(n)] for i in range(n): for j in range(n): nn[i][j] = min(i + 1, j + 1, n - i, n - j) # for l in nn: # print(l) # b , c = tin() pl = lin() ans = 0 for i, p in enumerate(pl): x, y = (p - 1) // n, (p - 1) % n ans += nn[x][y] - 1 is_sit[x][y] = 0 gg(nn, x, y, n, is_sit, cc, i) print(ans) # s = input() # +++++ isTest = False def pa(v): if isTest: print(v) def input_clipboard(): import clipboard input_text = clipboard.get() input_l = input_text.splitlines() for l in input_l: yield l if __name__ == "__main__": if sys.platform == "ios": if input_method == input_methods[0]: ic = input_clipboard() input = lambda: ic.__next__() elif input_method == input_methods[1]: sys.stdin = open("inputFile.txt") else: pass isTest = True else: pass input = sys.stdin.readline ret = main() if ret is not None: print(ret)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s951859370

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

from collections import defaultdict from collections import deque import math N = int(input()) P = list(map(int, input().split())) map = [] for i in range(N): map.append([]) for j in range(N): map[i].append(True) def check(x, y): distance = defaultdict(lambda: defaultdict(lambda: 500)) stack = deque() stack.append([x, y]) distance[x][y] = 0 min_d = 500 while len(stack) != 0: x_y = stack.popleft() new_x = x_y[0] new_y = x_y[1] distance_xy = distance[new_x][new_y] if distance_xy < min_d and ( new_x == 0 or new_y == 0 or new_x == N - 1 or new_y == N - 1 ): min_d = distance_xy if x <= new_x: if new_x + 1 < N: if distance[new_x + 1][new_y] == 500: stack.append([new_x + 1, new_y]) next_d = distance_xy if map[new_x + 1][new_y]: next_d += 1 if next_d < distance[new_x + 1][new_y]: distance[new_x + 1][new_y] = next_d if x >= new_x: if 0 <= new_x - 1: if distance[new_x - 1][new_y] == 500: stack.append([new_x - 1, new_y]) next_d = distance_xy if map[new_x - 1][new_y]: next_d += 1 if next_d < distance[new_x - 1][new_y]: distance[new_x - 1][new_y] = next_d if y <= new_y: if new_y + 1 < N: if distance[new_x][new_y + 1] == 500: stack.append([new_x, new_y + 1]) next_d = distance_xy if map[new_x][new_y + 1]: next_d += 1 if next_d < distance[new_x][new_y + 1]: distance[new_x][new_y + 1] = next_d if y >= new_y: if 0 <= new_y - 1: if distance[new_x][new_y - 1] == 500: stack.append([new_x, new_y - 1]) next_d = distance_xy if map[new_x][new_y - 1]: next_d += 1 if next_d < distance[new_x][new_y - 1]: distance[new_x][new_y - 1] = next_d return min_d result = 0 for p in P: px = (p - 1) % N py = math.floor((p - 1) / N) result += check(px, py) map[px][py] = False print(result)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s208779743

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

# -*- coding: utf-8 -*- import sys from collections import deque sys.setrecursionlimit(10**9) INF = 10**18 MOD = 10**9 + 7 input = lambda: sys.stdin.readline().rstrip() YesNo = lambda b: bool([print("Yes")] if b else print("No")) YESNO = lambda b: bool([print("YES")] if b else print("NO")) int1 = lambda x: int(x) - 1 def main(): N = int(input()) P = tuple(map(int1, input().split())) c = [[1] * N for _ in range(N)] ans = 0 dy, dx = [1, 0, -1, 0], [0, 1, 0, -1] class UnionFind: def __init__(self, n): self.par = [i for i in range(n)] self.siz = [1] * n def root(self, x): while self.par[x] != x: self.par[x] = self.par[self.par[x]] x = self.par[x] return x def unite(self, x, y): x = self.root(x) y = self.root(y) if x == y: return False if self.siz[x] < self.siz[y]: x, y = y, x self.siz[x] += self.siz[y] self.par[y] = x return True def is_same(self, x, y): return self.root(x) == self.root(y) def size(self, x): return self.siz[self.root(x)] u = UnionFind(N**2) dist = [INF] * (N**2) for p in P: que = deque([(p // N, p % N)]) d = [[INF] * N for _ in range(N)] d[p // N][p % N] = 0 f = True f2 = False MAX = INF while que and f: y, x = que.popleft() if f2 and d[y][x] >= MAX: tmp = MAX break for k in range(4): ny, nx = (y + dy[k], x + dx[k]) if 0 <= ny < N and 0 <= nx < N: if d[ny][nx] == INF: if c[ny][nx] == 1: d[ny][nx] = d[y][x] + 1 que.append((ny, nx)) else: MAX = min(MAX, d[y][x] + dist[u.root(ny * N + nx)]) f2 = True else: tmp = d[y][x] f = False break ans += tmp dist[u.root(p)] = tmp y, x = p // N, p % N for k in range(4): ny, nx = (y + dy[k], x + dx[k]) if 0 <= ny < N and 0 <= nx < N and c[ny][nx] == 0: res0 = u.root(p) res1 = u.root(ny * N + nx) u.unite(p, ny * N + nx) dist[u.root(p)] = min(dist[res0], dist[res1]) c[p // N][p % N] = 0 print(ans) if __name__ == "__main__": main()

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s350772673

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

N = int(input()) P = list(map(int, input().split())) import heapq def dijkstra_heap(s): # 始点sから各頂点への最短距離 d = [float("inf")] * (N**2) used = [True] * (N**2) # True:未確定 d[s] = 0 used[s] = False edgelist = [] for e in edge[s]: heapq.heappush(edgelist, e) while len(edgelist): minedge = heapq.heappop(edgelist) # まだ使われてない頂点の中から最小の距離のものを探す if not used[minedge[1]]: continue v = minedge[1] d[v] = minedge[0] used[v] = False for e in edge[v]: if used[e[1]]: heapq.heappush(edgelist, [e[0] + d[v], e[1]]) return d edge = [[] for i in range(N**2)] for i in range(N): for j in range(N): x = i * N + j if (i == 0) or (i == N - 1) or (j == 0) or (j == N - 1): edge[x].append([0, 0]) edge[0].append([0, x]) continue if j != 0: edge[x].append([1, x - 1]) edge[x - 1].append([1, x]) if j != N - 1: edge[x].append([1, x + 1]) edge[x + 1].append([1, x]) if i != 0: edge[x].append([1, x - N]) edge[x - N].append([1, x]) if i != N - 1: edge[x].append([1, x + N]) edge[x + N].append([1, x]) ans = 0 for p in P: x = p - 1 a = x // N b = x % N ans += dijkstra_heap(0)[x] if b != 0: edge[x].append([0, x - 1]) edge[x - 1].append([0, x]) if b != N - 1: edge[x].append([0, x + 1]) edge[x + 1].append([0, x]) if a != 0: edge[x].append([0, x - N]) edge[x - N].append([0, x]) if a != N - 1: edge[x].append([0, x + N]) edge[x + N].append([0, x]) print(ans)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s046203264

Runtime Error

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

import sys def _i(): return int(sys.stdin.readline().strip()) def _ia(): return map(int, sys.stdin.readline().strip().split()) def update(n, cost, flag, idx, ci): # left if idx % n != 0: idx_ = idx - 1 if cost[idx_] > ci: cost[idx_] = ci update(n, cost, flag, idx_, ci + flag[idx_]) # right idx_ = idx + 1 if idx_ % n != 0: if cost[idx_] > ci: cost[idx_] = ci update(n, cost, flag, idx_, ci + flag[idx_]) # front idx_ = idx - n if idx_ >= 0: if cost[idx_] > ci: cost[idx_] = ci update(n, cost, flag, idx_, ci + flag[idx_]) # back idx_ = idx + n if idx_ // n < n: if cost[idx_] > ci: cost[idx_] = ci update(n, cost, flag, idx_, ci + flag[idx_]) def main(): n = _i() p = list(map(lambda x: int(x) - 1, _ia())) cost = [min(i // n, i % n, n - 1 - (i % n), n - 1 - i // n) for i in range(n**2)] flag = [1] * n**2 tot = 0 for pi in p: flag[pi] = 0 ci = cost[pi] tot += ci update(n, cost, flag, pi, ci) return tot if __name__ == "__main__": print(main())

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s416057536

Accepted

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

N, *P = map(int, open(0).read().split()) dp = [0] + [min(i, j, N - 1 - i, N - 1 - j) for i in range(N) for j in range(N)] memo = [1] * (N * N + 1) def move(fr, to): if dp[to] > dp[fr] + memo[fr]: dp[to] = dp[fr] + memo[fr] S.append(to) ans = 0 for p in P: ans += dp[p] memo[p] = 0 S = [p] while S: v = S.pop() q, r = divmod(v - 1, N) if r != 0: move(v, v - 1) if r != N - 1: move(v, v + 1) if q < N - 1: move(v, v + N) if q >= 1: move(v, v - N) print(ans)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s106751814

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

print(3 | 6)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s632439649

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

print("軽い気持ちで参加してごめんなさい")

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s627387074

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

print(1)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s282905810

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

N = int(input()) P = input().split() M = [[1] * N for i in range(N)] Hate = 0 for ij in range(N**2): j = (int(P[ij]) - 1) % N i = (int(P[ij]) - 1) // N K1 = 0 K2 = 0 K3 = 0 K4 = 0 M[i][j] = 0 for k in range(0, i): if M[k][j] == 1: K1 += 1 for k in range(i, N): if M[k][j] == 1: K2 += 1 for k in range(0, j): if M[i][k] == 1: K3 += 1 for k in range(j, N): if M[i][k] == 1: K4 += 1 Hate += min(K1, K2, K3, K4) print(Hate)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s791566630

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

from collections import deque def main(): n = int(input()) p = list(map(int, input().split())) for i in range(len(p)): p[i] -= 1 to_outsides = [[0 for _ in range(n)] for _ in range(n)] not_exist = [["■" for _ in range(n)] for _ in range(n)] for i in range(n): for j in range(n): to_outside = [i, n - 1 - i, j, n - 1 - j] to_outsides[i][j] = min(to_outside) directions = [[-1, 0], [1, 0], [0, -1], [0, 1]] answer = 0 for i, person in enumerate(p): exited = [person // n, person % n] answer += to_outsides[exited[0]][exited[1]] not_exist[exited[0]][exited[1]] = "□" seen = deque() seen.append([exited[0], exited[1]]) todo = deque([exited]) renews = [] while len(todo) > 0: now = todo.pop() renews.append(now) for direction in directions: try: checking = [now[0] + direction[0], now[1] + direction[1]] to_outsides[checking[0]][checking[1]] except: continue if [checking[0], checking[1]] not in seen: if ( not_exist[checking[0]][checking[1]] == "□" and to_outsides[checking[0]][checking[1]] == to_outsides[now[0]][now[1]] ) or to_outsides[checking[0]][checking[1]] > to_outsides[now[0]][ now[1] ]: todo.append([checking[0], checking[1]]) seen.append([checking[0], checking[1]]) else: seen.append([checking[0], checking[1]]) for renew in renews: if to_outsides[renew[0]][renew[1]] != 0: to_outsides[renew[0]][renew[1]] -= 1 print(answer) main()

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s778147169

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

from collections import deque N = int(input()) offset = 0 field = N people = [[1 for _ in range(field)] for _ in range(field)] HL = [0] * N HR = [0] * N Hcnt = 0 for P in input().split(): visited = [[600 for _ in range(field)] for _ in range(field)] seen = [[0 for _ in range(field)] for _ in range(field)] nowx = (int(P) - 1) // N nowy = (int(P) - 1) % N todo = deque() todo.append((nowx, nowy)) mv = [(0, 1), (1, 0), (-1, 0), (0, -1)] seen[nowx][nowy] += 1 people[nowx][nowy] = 0 visited[nowx][nowy] = 0 flag = False while len(todo) > 0: nowx, nowy = todo.popleft() for i in range(len(mv)): dx, dy = mv[i] nx = nowx + dx ny = nowy + dy if nx >= N or nx < 0 or ny >= N or ny < 0: continue if visited[nx][ny] > visited[nowx][nowy] + people[nx][ny]: visited[nx][ny] = visited[nowx][nowy] + people[nx][ny] seen[nx][ny] += 1 if seen[nx][ny] > 3: continue todo.append((nx, ny)) if flag: break for n in range(N): HL[n] = visited[n][0] HR[n] = visited[n][N - 1] Hcnt += min(min(visited[0]), min(visited[N - 1]), min(HL), min(HR)) print(Hcnt)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

If ans is the number of pairs of viewers described in the statement, you should print on Standard Output ans * * *

s990379507

Wrong Answer

p02670

The input is given from Standard Input in the format N P_1 P_2 \cdots P_{N^2}

def chk_1st_row(p_l, N): if p_l <= N: return True else: return False def chk_last_row(p_l, N): if N**2 - N + 1 <= p_l: return True else: return False def chk_isle(p_l, N): if p_l % N == 0 or p_l % N == 1: return True else: return False def chk_right(p_l, p, N): # print(p_l, ',', N * (p_l // N + 1)) for i in range(p_l + 1, N * (p_l // N + 1) + 1): if i in p: return True return False def chk_left(p_l, p, N): # print(p_l, N * (p_l // N)) for i in range(N * (p_l // N) + 1, p_l): if i in p: return True return False def chk_front(p_l, p, N): while p_l > 0: p_l -= N if p_l in p: return True break return False def chk_rear(p_l, p, N): while p_l < N**2: p_l += N if p_l in p: return True break return False N = int(input()) count = 0 in_theater = [] for i in range(1, N**2 + 1): in_theater.append(i) p = list(map(int, input().split())) # print(p) for i in range(N**2): p_l = p[0] p.remove(p[0]) if chk_1st_row(p_l, N): continue elif chk_last_row(p_l, N): continue elif chk_isle(p_l, N): continue elif not (chk_right(p_l, p, N)): continue elif not (chk_left(p_l, p, N)): continue elif not (chk_front(p_l, p, N)): continue elif not (chk_rear(p_l, p, N)): continue count += 1 # print(p_l, count) print(count)

Statement Tonight, in your favourite cinema they are giving the movie Joker and all seats are occupied. In the cinema there are N rows with N seats each, forming an N\times N square. We denote with 1, 2,\dots, N the viewers in the first row (from left to right); with N+1, \dots, 2N the viewers in the second row (from left to right); and so on until the last row, whose viewers are denoted by N^2-N+1,\dots, N^2. At the end of the movie, the viewers go out of the cinema in a certain order: the i-th viewer leaving her seat is the one denoted by the number P_i. The viewer P_{i+1} waits until viewer P_i has left the cinema before leaving her seat. To exit from the cinema, a viewer must move from seat to seat until she exits the square of seats (any side of the square is a valid exit). A viewer can move from a seat to one of its 4 adjacent seats (same row or same column). While leaving the cinema, it might be that a certain viewer x goes through a seat **currently** occupied by viewer y; in that case viewer y will hate viewer x forever. Each viewer chooses the way that minimizes the number of viewers that will hate her forever. Compute the number of pairs of viewers (x, y) such that y will hate x forever.

[{"input": "3\n 1 3 7 9 5 4 8 6 2", "output": "1\n \n\nBefore the end of the movie, the viewers are arranged in the cinema as\nfollows:\n\n \n \n 1 2 3\n 4 5 6\n 7 8 9\n \n\nThe first four viewers leaving the cinema (1, 3, 7, 9) can leave the cinema\nwithout going through any seat, so they will not be hated by anybody.\n\nThen, viewer 5 must go through one of the seats where viewers 2, 4, 6, 8 are\ncurrently seated while leaving the cinema; hence he will be hated by at least\none of those viewers.\n\nFinally the remaining viewers can leave the cinema (in the order 4, 8, 6, 2)\nwithout going through any occupied seat (actually, they can leave the cinema\nwithout going through any seat at all).\n\n* * *"}, {"input": "4\n 6 7 1 4 13 16 10 9 5 11 12 14 15 2 3 8", "output": "3\n \n\n* * *"}, {"input": "6\n 11 21 35 22 7 36 27 34 8 20 15 13 16 1 24 3 2 17 26 9 18 32 31 23 19 14 4 25 10 29 28 33 12 6 5 30", "output": "11"}]

Print the possible ways Ringo could have thrown in K balls, modulo 998244353. * * *

s202745414

Wrong Answer

p03431

Input is given from Standard Input in the following format: N K

m = 998244353 def c(n, r): return (g[n] * h[r] * h[n - r]) % m g = [1, 1] h = g[:] v = [0, 1] for i in range(2, 999999): g.append((g[-1] * i) % m) v.append((-v[m % i] * (m // i)) % m) h.append((h[-1] * v[i]) % m) N, K = map(int, input().split()) P = 0 for k in range(N - 1, K): P += c(K - 1, k) print(P)

Statement In Republic of AtCoder, Snuke Chameleons (Family: Chamaeleonidae, Genus: Bartaberia) are very popular pets. Ringo keeps N Snuke Chameleons in a cage. A Snuke Chameleon that has not eaten anything is blue. It changes its color according to the following rules: * A Snuke Chameleon that is blue will change its color to red when the number of red balls it has eaten becomes strictly larger than the number of blue balls it has eaten. * A Snuke Chameleon that is red will change its color to blue when the number of blue balls it has eaten becomes strictly larger than the number of red balls it has eaten. Initially, every Snuke Chameleon had not eaten anything. Ringo fed them by repeating the following process K times: * Grab either a red ball or a blue ball. * Throw that ball into the cage. Then, one of the chameleons eats it. After Ringo threw in K balls, all the chameleons were red. We are interested in the possible ways Ringo could have thrown in K balls. How many such ways are there? Find the count modulo 998244353. Here, two ways to throw in balls are considered different when there exists i such that the color of the ball that are thrown in the i-th throw is different.

[{"input": "2 4", "output": "7\n \n\nWe will use `R` to represent a red ball, and `B` to represent a blue ball.\nThere are seven ways to throw in balls that satisfy the condition: `BRRR`,\n`RBRB`, `RBRR`, `RRBB`, `RRBR`, `RRRB` and `RRRR`.\n\n* * *"}, {"input": "3 7", "output": "57\n \n\n* * *"}, {"input": "8 3", "output": "0\n \n\n* * *"}, {"input": "8 10", "output": "46\n \n\n* * *"}, {"input": "123456 234567", "output": "857617983"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s320299860

Accepted

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

# AtCoder Beginner Contest 075 # B - Minesweeper # https://atcoder.jp/contests/abc075/tasks/abc075_b H, W, *S = open(0).read().split() H, W = int(H), int(W) S = [tuple(s) for s in S] ans = [[0] * W for _ in [0] * H] dirs = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)] for y, _s in enumerate(S): for x, s in enumerate(_s): if s == "#": ans[y][x] = "#" for dy, dx in dirs: if 0 <= x + dx < W and 0 <= y + dy < H and S[y + dy][x + dx] != "#": ans[y + dy][x + dx] += 1 for a in ans: print("".join(map(str, a)))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s604547859

Accepted

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

def read_input(): h, w = map(int, input().split()) slist = [] for i in range(h): slist.append(input().strip()) return h, w, slist # i, jの周辺に1を足す def sumup(board, i, j): def notbomb(x): return x != "#" up = i - 1 >= 0 down = i + 1 < len(board) left = j - 1 >= 0 right = j + 1 < len(board[0]) if up: if notbomb(board[i - 1][j]): board[i - 1][j] += 1 if left: if notbomb(board[i - 1][j - 1]): board[i - 1][j - 1] += 1 if right: if notbomb(board[i - 1][j + 1]): board[i - 1][j + 1] += 1 if left: if notbomb(board[i][j - 1]): board[i][j - 1] += 1 if right: if notbomb(board[i][j + 1]): board[i][j + 1] += 1 if down: if notbomb(board[i + 1][j]): board[i + 1][j] += 1 if left: if notbomb(board[i + 1][j - 1]): board[i + 1][j - 1] += 1 if right: if notbomb(board[i + 1][j + 1]): board[i + 1][j + 1] += 1 return board def submit(): h, w, slist = read_input() board = [] for s in slist: board.append([0 if c == "." else c for c in s]) for i in range(h): for j in range(w): if board[i][j] == "#": board = sumup(board, i, j) for row in board: print("".join([str(c) for c in row])) if __name__ == "__main__": submit()

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s940115479

Wrong Answer

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

g, r = map(int, input().split()) A = ["." * (r + 2)] for i in range(g): w = "." + input() + "." A.append(w) A.append("." * (r + 2)) print(A) for i in range(1, g + 1): for j in range(1, r + 1): if A[i][j] == ".": B = [] for m in [i - 1, i, i + 1]: for k in [j - 1, j, j + 1]: B.append(A[m][k]) print(B) print(B.count("#")) A[i] = A[i][1 : r + 1 :].replace(".", str(B.count("#")), 1) A[i] = "." + A[i] + "." for i in range(1, g + 1): print(A[i][1 : r + 1 :])

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s684594618

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H, W = map(int, input().split()) S = [list(input()) for i in range(H)] for i in range(1, H - 1): for j in range(1, W - 1): if S[i][j] == ".": x = [ S[i - 1][j - 1], S[i - 1][j], S[i - 1][j + 1], S[i][j - 1], S[i][j + 1], S[i + 1][j - 1], S[i + 1][j], S[i + 1][j + 1], ] S[i][j] = x.count("#") for j in range(1, W - 1): if S[0][j] == ".": x = [S[0][j - 1], S[0][j + 1], S[1][j - 1], S[1][j], S[1][j + 1]] S[0][j] = x.count("#") if S[H - 1][j] == ".": x = [ S[H - 1][j - 1], S[H - 1][j + 1], S[H - 2][j - 1], S[H - 2][j], S[H - 2][j + 1], ] S[H - 1][j] = x.count("#") for i in range(1, H - 1): if S[i][0] == ".": x = [S[i - 1][0], S[i - 1][1], S[i][1], S[i + 1][0], S[i + 1][1]] S[i][0] = x.count("#") if S[i][W - 1] == ".": x = [ S[i - 1][W - 1], S[i - 1][W - 2], S[i][W - 2], S[i + 1][W - 1], S[i + 1][W - 2], ] S[i][W - 1] = x.count("#") if S[0][0] == ".": x = [S[0][1], S[1][0], S[1][1]] S[0][0] = x.count("#") if S[H - 1][0] == ".": x = [S[H - 1][1], S[H - 2][0], S[H - 2][1]] S[H - 1][0] = x.count("#") if S[0][W - 1] == ".": x = [S[0][W - 2], S[1][W - 1], S[1][W - 2]] S[0][W - 1] = x.count("#") if S[H - 1][W - 1] == ".": x = [S[H - 1][W - 2], S[H - 2][W - 1], S[H - 2][W - 2]] S[H - 1][W - 1] = x.count("#") for i in range(len(S)): S[i] = [str(x) for x in S[i]] print("".join(S[i]))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s805350284

Wrong Answer

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

def check_current_posi(s_i_list, h, w): _height = len(s_i_list) _width = len(s_i_list[0]) if h == -1 or w == -1 or h >= _height or w >= _width: return False else: if s_i_list[h][w] == "#": # bomb return True else: # not bomb return False # hとwは0から def check_around_bomb_num(s_i_list, h, w): check_posi_h = h - 1 check_posi_w = w - 1 bomb_counter = 0 for i in range(3): for j in range(3): if check_current_posi(s_i_list, check_posi_h, check_posi_w): bomb_counter += 1 check_posi_w += 1 check_posi_h += 1 check_posi_w = w - 1 return bomb_counter # _input = [6, 6] _input = list(map(int, input().split(" "))) height = _input[0] width = _input[1] s_i_list = [] for i in range(height): _input_row = list(input()) s_i_list.append(_input_row) # s_i_list = [['#', '#', '#', '#', '#', '.'], ['#', '.', '#', '.', '#', '#'], ['#', '#', '#', '#', '.', '#'], ['.', '#', '.', '.', '#', '.'], ['#', '.', '#', '#', '.', '.'], ['#', '.', '#', '.', '.', '.']] for row in range(height): for column in range(width): if s_i_list[row][column] == "#": continue s_i_list[row][column] = check_around_bomb_num(s_i_list, row, column) print(s_i_list)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s386386991

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w = map(int, input().split()) s = [list(input()) for _ in range(h)] ans = [[0]*w for _ in range(h)] for i in range(h): for j in range(w): if s[i][j] == "#": ans[i][j] = "#" for i2 in range(i-1, i+2): if i2 < 0 or h-1 < i2: continue for j2 in range(j-1, j+2): if (j2 < 0 or w-1 < j2): continue elif ans[i2][j2] == "#": continue ans[i2][j2] += 1 for i in ans: print("".join(map(str,i)))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s879382201

Accepted

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

li = [] a, b = map(int, input().split()) for i in range(a): li.append(list(input())) for i in range(a): for j in range(b): if li[i][j] == ".": li[i][j] = 0 if i != 0 and li[i - 1][j] == "#": li[i][j] += 1 if i != a - 1 and li[i + 1][j] == "#": li[i][j] += 1 if j != 0 and li[i][j - 1] == "#": li[i][j] += 1 if j != b - 1 and li[i][j + 1] == "#": li[i][j] += 1 if i != 0 and j != 0 and li[i - 1][j - 1] == "#": li[i][j] += 1 if i != a - 1 and j != 0 and li[i + 1][j - 1] == "#": li[i][j] += 1 if i != 0 and j != b - 1 and li[i - 1][j + 1] == "#": li[i][j] += 1 if i != a - 1 and j != b - 1 and li[i + 1][j + 1] == "#": li[i][j] += 1 print(li[i][j], end="") print()

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s471897635

Accepted

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H, W = [int(i) for i in input().split(" ")] S = [input() for i in range(H)] for k, v in enumerate(S): for kk, vv in enumerate(list(v)): checkTarget = [] if vv == "#": print("#", end="") else: if H == 1 and W == 1: print("0", end="") break if k == 0 and kk == 0: checkTarget = [S[k][kk + 1], S[k + 1][kk], S[k + 1][kk + 1]] elif k == 0 and kk > 0 and kk < len(v) - 1 and H == 1: checkTarget = [ S[k][kk - 1], S[k][kk + 1], ] elif k == 0 and kk > 0 and kk < len(v) - 1: checkTarget = [ S[k][kk - 1], S[k][kk + 1], S[k + 1][kk - 1], S[k + 1][kk], S[k + 1][kk + 1], ] elif k == 0 and kk == len(v) - 1 and H == 1: checkTarget = [ S[k][kk - 1], ] elif k == 0 and kk == len(v) - 1: checkTarget = [S[k][kk - 1], S[k + 1][kk - 1], S[k + 1][kk]] elif k > 0 and k < len(S) - 1 and kk == 0 and W == 1: checkTarget = [S[k - 1][kk], S[k + 1][kk]] elif k > 0 and k < len(S) - 1 and kk == 0: checkTarget = [ S[k - 1][kk], S[k - 1][kk + 1], S[k][kk + 1], S[k + 1][kk], S[k + 1][kk + 1], ] elif k > 0 and k < len(S) - 1 and kk == len(v) - 1: checkTarget = [ S[k - 1][kk - 1], S[k - 1][kk], S[k][kk - 1], S[k + 1][kk - 1], S[k + 1][kk], ] elif k == len(S) - 1 and kk == 0 and W == 1: checkTarget = [S[k - 1][kk]] elif k == len(S) - 1 and kk == 0: checkTarget = [S[k - 1][kk], S[k - 1][kk + 1], S[k][kk + 1]] elif k == len(S) - 1 and kk > 0 and kk < len(v) - 1: checkTarget = [ S[k - 1][kk - 1], S[k - 1][kk], S[k - 1][kk + 1], S[k][kk - 1], S[k][kk + 1], ] elif k == len(S) - 1 and kk == len(v) - 1: checkTarget = [S[k - 1][kk - 1], S[k - 1][kk], S[k][kk - 1]] else: checkTarget = [ S[k - 1][kk - 1], S[k - 1][kk], S[k - 1][kk + 1], S[k][kk - 1], S[k][kk + 1], S[k + 1][kk - 1], S[k + 1][kk], S[k + 1][kk + 1], ] print(len([i for i in checkTarget if i == "#"]), end="") print("", end="\n" if k != len(S) - 1 else "")

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s360117403

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

x = input().split() h = int(x[0]) w = int(x[1]) inp = [0] * h * w for i in range(h): x = input() y = 0 r = i * w for j in x: if j == "#": inp[r + y] = "#" if r + y == 0: if inp[r + y + 1] != "#": inp[r + y + 1] += 1 if inp[r + y + w] != "#": inp[r + y + w] += 1 if inp[r + y + w + 1] != "#": inp[r + y + w + 1] += 1 elif r + y == w - 1: if inp[w - 2] != "#": inp[w - 2] += 1 if inp[w - 1 + w] != "#": inp[w - 1 + w] += 1 if inp[w - 2 + w] != "#": inp[w - 2 + w] += 1 elif r + y == (h - 1) * w: if inp[r + y - w] != "#": inp[r + y - w] += 1 if inp[r + y - w + 1] != "#": inp[r + y - w + 1] += 1 if inp[r + y + 1] != "#": inp[r + y + 1] += 1 elif r + y == h * w - 1: if inp[r + y - 1] != "#": inp[r + y - 1] += 1 if inp[r + y - w - 1] != "#": inp[r + y - w - 1] += 1 if inp[r + y - w] != "#": inp[r + y - w] += 1 elif r + y < w - 1: if inp[r + y - 1] != "#": inp[r + y - 1] += 1 if inp[r + y + 1] != "#": inp[r + y + 1] += 1 if inp[r + y + w] != "#": inp[r + y + w] += 1 if inp[r + y + w - 1] != "#": inp[r + y + w - 1] += 1 if inp[r + y + w + 1] != "#": inp[r + y + w + 1] += 1 elif (r + y) % w == 0: if inp[r + y - w] != "#": inp[r + y - w] += 1 if inp[r + y + 1] != "#": inp[r + y + 1] += 1 if inp[r + y + w] != "#": inp[r + y + w] += 1 if inp[r + y - w + 1] != "#": inp[r + y - w + 1] += 1 if inp[r + y + w + 1] != "#": inp[r + y + w + 1] += 1 elif (r + y) % w == w - 1: if inp[r + y - 1] != "#": inp[r + y - 1] += 1 if inp[r + y - w] != "#": inp[r + y - w] += 1 if inp[r + y + w] != "#": inp[r + y + w] += 1 if inp[r + y + w - 1] != "#": inp[r + y + w - 1] += 1 if inp[r + y - w - 1] != "#": inp[r + y - w - 1] += 1 elif r + y > (h - 1) * w: if inp[r + y - 1] != "#": inp[r + y - 1] += 1 if inp[r + y + 1] != "#": inp[r + y + 1] += 1 if inp[r + y - w] != "#": inp[r + y - w] += 1 if inp[r + y - w - 1] != "#": inp[r + y - w - 1] += 1 if inp[r + y - w + 1] != "#": inp[r + y - w + 1] += 1 else: if inp[r + y - 1] != "#": inp[r + y - 1] += 1 if inp[r + y + 1] != "#": inp[r + y + 1] += 1 if inp[r + y + w] != "#": inp[r + y + w] += 1 if inp[r + y + w - 1] != "#": inp[r + y + w - 1] += 1 if inp[r + y + w + 1] != "#": inp[r + y + w + 1] += 1 if inp[r + y - w] != "#": inp[r + y - w] += 1 if inp[r + y - w + 1] != "#": inp[r + y - w + 1] += 1 if inp[r + y - w - 1] != "#": inp[r + y - w - 1] += 1 y += 1 ans = "" for i in range(h): for j in range(w): ans += str(inp[i * w + j]) print(ans) ans = ""

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s558858965

Wrong Answer

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

import sys if sys.platform == "ios": sys.stdin = open("input.txt") h, w = [int(x) for x in input().split()] board = [input() for _ in range(h)] mines = ["" for _ in range(h)] print(board) for row in range(h): for col in range(w): if board[row][col] != "#": counts = 0 dx = [x for x in range(-1, 2) if (col + x >= 0 and col + x < w)] dy = [y for y in range(-1, 2) if (row + y >= 0 and row + y < h)] # print('row:{}, col:{}, dx:{}, dy:{}'.format(row,col,dx,dy)) for x in dx: for y in dy: # print('row+y:{}, col+x:{}'.format(row+y, col+x)) if board[row + y][col + x] == "#": counts += 1 mines[row] += str(counts) else: mines[row] += "#" for mine in mines: print(mine)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s259808537

Accepted

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

a, b = map(int, input().split()) c = [] for i in range(a): c.append(list(input().replace(".", "0"))) for i in range(a): for j in range(b): if c[i][j] == "#": for x in range(i - 1, i + 2): for y in range(j - 1, j + 2): if 0 <= x <= a - 1 and 0 <= y <= b - 1 and c[x][y] != "#": c[x][y] = str(int(c[x][y]) + 1) for i in range(a): print("".join(c[i]))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s651390911

Accepted

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

import sys sys.setrecursionlimit(200000) def input(): return sys.stdin.readline()[:-1] def ii(t: type = int): return t(input()) def il(t: type = int): return list(map(t, input().split())) def imi(N: int, t: type = int): return [ii(t) for _ in range(N)] def iml(N: int, t: type = int): return [il(t) for _ in range(N)] class UnionFind: def __init__(self, n): self.par = [i for i in range(n)] self.rank = [0] * (n) # 検索 def find(self, x): if self.par[x] == x: return x else: self.par[x] = self.find(self.par[x]) return self.par[x] # 併合 def union(self, x, y): x = self.find(x) y = self.find(y) if self.rank[x] < self.rank[y]: self.par[x] = y else: self.par[y] = x if self.rank[x] == self.rank[y]: self.rank[x] += 1 # 同じ集合に属するか判定 def same_check(self, x, y): return self.find(x) == self.find(y) def solve(): H, W = il() S = imi(H, str) from itertools import product dst = ((i, j) for i, j in product(range(-1, 2), repeat=2)) dst = list(dst) B = [[0] * W for _ in range(H)] sharp_pos = [] for i, j in product(range(H), range(W)): if S[i][j] == "#": B[i][j] = "#" sharp_pos.append((i, j)) for i, j in sharp_pos: for d in dst: x = i + d[1] y = j + d[0] if 0 <= x < H and 0 <= y < W: if S[i][j] == "#" and S[x][y] == ".": B[x][y] += 1 for b in B: print("".join(map(str, b))) if __name__ == "__main__": solve()

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s113240789

Wrong Answer

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H, W = map(int, input().split()) Ws = W + 2 Hs = H + 2 root = [[0] * Ws for i in range(Hs)] c = 0 for i in range(H): I = "" I = input() print(I) for j in range(W): print("youso is ", I[j]) k = I[j] root[i + 1][j + 1] = k root2 = [[0] * W for i in range(H)] for i in range(H): for j in range(W): if root[i + 1][j + 1] == ".": c = 0 if root[i + 1 + 1][j + 1 + 1] == "#": c += 1 if root[i + 1 + 1][j + 1] == "#": c += 1 if root[i + 1 + 1][j - 1 + 1] == "#": c += 1 if root[i + 1 - 1][j + 1 + 1] == "#": c += 1 if root[i + 1 - 1][j + 1] == "#": c += 1 if root[i + 1 - 1][j - 1 + 1] == "#": c += 1 if root[i + 1 + 1][j + 1 + 1] == "#": c += 1 if root[i + 1 + 1][j + 1 - 1] == "#": c += 1 root2[i][j] = c else: root2[i][j] = "#" for i in range(H): print(root[H])

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s059787465

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

Y_DIR[-1,0,1] X_DIR[-1,0,1] def count_bomb(y,x): cnt=0 for yd in Y_DIR: yy=y+yd if not (0<=yy<h): continue for xd in X_DIR: xx=x+xd if not (0<=xx<w): continue if s[yy][xx]=="#": cnt+=1 return cnt h,w=map(int,input().split()) s=[] for i in range(h): s.append(input()) for y in range(h): for x in range(w) if s[y][x] == ".": s[y][x]=str(count_bomb(y,x)) print("\n".join(s))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s772279123

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H, W = map(int, input().split()) S = [list(input()) for _ in range(H)] dydx = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)] def check(h, w): count = 0 for dy, dx in dydx: if 0 <= h + dy < H and 0 <= w + dx < W and S[h+dy][w+dx] == '#': count += 1 return count for h in range(H): for w in range(W): if S[h][w] == '.': S[h][w] = check(h, w) print("".join(S[h])

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s192632888

Wrong Answer

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h, w = map(int, input().split()) S = [] for i in range(h): S.append(list(input())) if h == 1 and w == 1: print(S[0][0]) if h == 1 and w == 2: if S == [[".", "#"]]: print("1#") if S == [["#", "#"]]: print("##") if S == [["#", "."]]: print("#1") if S == [[".", "."]]: print("..") if h == 1 and w >= 3: for g in range(w): if S[0][0] == ".": if S[0][1] == "#": S[0][0] = "1" if 1 <= g <= w - 2: if S[0][g] == ".": S[0][g] = str(S[0][g - 1 : g + 2].count("#")) if S[0][w - 1] == ".": if S[0][w - 2] == "#": S[0][w - 1] = "1" print("".join(S[0])) if h >= 3 and w == 1: for y in range(h): if S[0][0] == ".": if S[1][0] == "#": S[0][0] = "1" if 1 <= y <= h - 2: if S[y][0] == ".": count = 0 if S[y - 1][0] == "#": count += 1 if S[y + 1][0] == "#": count += 1 S[y][0] = int(count) if S[h - 1][0] == ".": if S[h - 2][0] == "#": S[h - 1][0] = "1" for p in S: print(p[0]) if h == 2 and w == 1: if S == [["."], ["."]]: print(".") print(".") if S == [["#"], ["."]]: print("#") print("1") if S == [["."], ["#"]]: print("1") print("#") if S == [["#"], ["#"]]: print("#") print("#") if h >= 2 and w >= 2: for k in range(h): for j in range(w): if S[k][j] == ".": if k == 0 and j == 0: count = 0 if S[0][1] == "#": count += 1 count += S[1][0:2].count("#") S[k][j] = str(count) elif k == 0 and 1 <= j <= w - 2: count = 0 count += S[0][j - 1 : j + 2].count("#") count += S[1][j - 1 : j + 2].count("#") S[k][j] = str(count) elif k == 0 and j == w - 1: count = 0 if S[0][j - 1] == "#": count += 1 count += S[1][j - 1 :].count("#") S[k][j] = str(count) elif 1 <= k <= h - 2 and j == 0: count = 0 count += S[k - 1][0:2].count("#") if S[k][1] == "#": count += 1 count += S[k + 1][0:2].count("#") S[k][j] = str(count) elif 1 <= k <= h - 2 and 1 <= j <= w - 2: count = 0 count += S[k - 1][j - 1 : j + 2].count("#") count += S[k][j - 1 : j + 2].count("#") count += S[k + 1][j - 1 : j + 2].count("#") S[k][j] = str(count) elif 1 <= k <= h - 2 and j == w - 1: count = 0 count += S[k - 1][j - 1 :].count("#") count += S[k][j - 1 :].count("#") count += S[k + 1][j - 1 :].count("#") S[k][j] = str(count) elif k == h - 1 and j == 0: count = 0 count += S[k - 1][0:2].count("#") count += S[k][1].count("#") S[k][j] = str(count) elif k == h - 1 and 1 <= j <= w - 2: count = 0 count += S[k - 1][j - 1 : j + 2].count("#") count += S[k][j - 1 : j + 2].count("#") S[k][j] = str(count) elif k == h - 1 and j == w - 1: count = 0 count += S[k - 1][j - 1 :].count("#") count += S[k][j - 1 :].count("#") S[k][j] = str(count) for p in S: print("".join(p))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s945524297

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

# 全日本汚いコード選手権Pythonの部 H, W = map(int, input().split()) S = [] for i in range(H): S.append(list(input())) L = [[0 for w in range(W)] for h in range(H)] if S[0][1] == "#": L[0][0] += 1 if S[1][0] == "#": L[0][0] += 1 if S[1][1] == "#": L[0][0] += 1 if S[H - 1][1] == "#": L[H - 1][0] += 1 if S[H - 2][0] == "#": L[H - 1][0] += 1 if S[H - 2][1] == "#": L[H - 1][0] += 1 if S[0][W - 2] == "#": L[0][W - 1] += 1 if S[1][W - 1] == "#": L[0][W - 1] += 1 if S[1][W - 2] == "#": L[0][W - 1] += 1 if S[H - 1][W - 2] == "#": L[H - 1][W - 1] += 1 if S[H - 2][W - 1] == "#": L[H - 1][W - 1] += 1 if S[H - 2][W - 2] == "#": L[H - 1][W - 1] += 1 for w in range(1, W - 1): if S[0][w - 1] == "#": L[0][w] += 1 if S[0][w + 1] == "#": L[0][w] += 1 if S[1][w - 1] == "#": L[0][w] += 1 if S[1][w] == "#": L[0][w] += 1 if S[1][w + 1] == "#": L[0][w] += 1 if S[H - 1][w - 1] == "#": L[H - 1][w] += 1 if S[H - 1][w + 1] == "#": L[H - 1][w] += 1 if S[H - 2][w - 1] == "#": L[H - 1][w] += 1 if S[H - 2][w] == "#": L[H - 1][w] += 1 if S[H - 2][w + 1] == "#": L[H - 1][w] += 1 for h in range(1, H - 1): if S[h - 1][0] == "#": L[h][0] += 1 if S[h + 1][0] == "#": L[h][0] += 1 if S[h - 1][1] == "#": L[h][0] += 1 if S[h][1] == "#": L[h][0] += 1 if S[h + 1][1] == "#": L[h][0] += 1 if S[h - 1][W - 1] == "#": L[h][W - 1] += 1 if S[h + 1][W - 1] == "#": L[h][W - 1] += 1 if S[h - 1][W - 2] == "#": L[h][W - 1] += 1 if S[h][W - 2] == "#": L[h][W - 1] += 1 if S[h + 1][W - 2] == "#": L[h][W - 1] += 1 for w in range(1, W - 1): for h in range(1, H - 1): if S[h - 1][w - 1] == "#": L[h][w] += 1 if S[h - 1][w] == "#": L[h][w] += 1 if S[h - 1][w + 1] == "#": L[h][w] += 1 if S[h][w - 1] == "#": L[h][w] += 1 if S[h][w + 1] == "#": L[h][w] += 1 if S[h + 1][w - 1] == "#": L[h][w] += 1 if S[h + 1][w] == "#": L[h][w] += 1 if S[h + 1][w + 1] == "#": L[h][w] += 1 C = [["" for w in range(W)] for h in range(H)] for w in range(W): for h in range(H): if S[h][w] == ".": C[h][w] = str(L[h][w]) else: C[h][w] = "#" o = "" for c in C: o = "" for cc in c: o += cc print(o)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s792176637

Wrong Answer

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H, W = map(int, input().split(" ")) S = [] for i in range(H): S.append(list(input())) for i in range(H): for j in range(W): if S[i][j] == ".": S[i][j] = 0 if H == 1 and W == 1: print(S[0][0]) elif H == 1: if S[0][0] == "#": if S[0][1] != "#": S[0][1] += 1 if S[0][W - 1] == "#": if S[0][W - 2] != "#": S[0][W - 2] += 1 print("test") for i in range(1, H - 1): if S[0][i - 1] != "#": S[0][i - 1] += 1 if S[0][i + 1] != "#": S[0][i + 1] += 1 for i in range(H): print("".join(map(str, S[i][:]))) elif W == 1: if S[0][0] == "#": if S[1][0] != "#": S[1][0] += 1 if S[H - 1][0] == "#": if S[H - 2][0] != "#": S[H - 2][0] += 1 for i in range(1, W - 1): if S[i - 1][0] != "#": S[i - 1][0] += 1 if S[i + 1][0] != "#": S[i + 1][0] += 1 for i in range(H): print("".join(map(str, S[i][:]))) else: # 4隅の処理 if S[0][0] == "#": if S[1][0] != "#": S[1][0] += 1 if S[0][1] != "#": S[0][1] += 1 if S[1][1] != "#": S[1][1] += 1 if S[0][W - 1] == "#": if S[0][W - 2] != "#": S[0][W - 2] += 1 if S[1][W - 2] != "#": S[1][W - 2] += 1 if S[1][W - 1] != "#": S[1][W - 1] += 1 if S[H - 1][0] == "#": if S[H - 2][0] != "#": S[H - 2][0] += 1 if S[H - 1][1] != "#": S[H - 1][1] += 1 if S[H - 2][1] != "#": S[H - 2][1] += 1 if S[H - 1][W - 1] == "#": if S[H - 2][W - 1] != "#": S[H - 2][W - 1] += 1 if S[H - 2][W - 2] != "#": S[H - 2][W - 2] += 1 if S[H - 1][W - 2] != "#": S[H - 1][W - 2] += 1 # 端の処理 for i in range(1, H - 1): if S[i][0] == "#": if S[i - 1][0] != "#": S[i - 1][0] += 1 if S[i + 1][0] != "#": S[i + 1][0] += 1 if S[i][1] != "#": S[i][1] += 1 if S[i - 1][1] != "#": S[i - 1][1] += 1 if S[i + 1][1] != "#": S[i + 1][1] += 1 for i in range(1, H - 1): if S[i][W - 1] == "#": if S[i - 1][W - 1] != "#": S[i - 1][W - 1] += 1 if S[i + 1][W - 1] != "#": S[i + 1][W - 1] += 1 if S[i][W - 2] != "#": S[i][W - 2] += 1 if S[i - 1][W - 2] != "#": S[i - 1][W - 2] += 1 if S[i + 1][W - 2] != "#": S[i + 1][W - 2] += 1 for i in range(1, W - 1): if S[0][i] == "#": if S[0][i - 1] != "#": S[0][i - 1] += 1 if S[0][i + 1] != "#": S[0][i + 1] += 1 if S[1][i] != "#": S[1][i] += 1 if S[1][i - 1] != "#": S[1][i - 1] += 1 if S[1][i + 1] != "#": S[1][i + 1] += 1 for i in range(1, W - 1): if S[H - 1][i] == "#": if S[H - 1][i - 1] != "#": S[H - 1][i - 1] += 1 if S[H - 1][i + 1] != "#": S[H - 1][i + 1] += 1 if S[H - 2][i] != "#": S[H - 2][i] += 1 if S[H - 2][i - 1] != "#": S[H - 2][i - 1] += 1 if S[H - 2][i + 1] != "#": S[H - 2][i + 1] += 1 for i in range(1, H - 1): for j in range(1, W - 1): if S[i][j] == "#": if S[i - 1][j - 1] != "#": S[i - 1][j - 1] += 1 if S[i - 1][j] != "#": S[i - 1][j] += 1 if S[i - 1][j + 1] != "#": S[i - 1][j + 1] += 1 if S[i][j - 1] != "#": S[i][j - 1] += 1 if S[i][j + 1] != "#": S[i][j + 1] += 1 if S[i + 1][j - 1] != "#": S[i + 1][j - 1] += 1 if S[i + 1][j] != "#": S[i + 1][j] += 1 if S[i + 1][j + 1] != "#": S[i + 1][j + 1] += 1 for i in range(H): print("".join(map(str, S[i][:]))) # # def replace(i,j,S): # yp = i + 1 # ym = i - 1 # xp = j + 1 # xm = j - 1 # count = 0 # if ym >= 0: # if S[ym][j] == "#": # count += 1 # if S[yp][j] == "#": # count += 1 # return S # # print(S) # print(S)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s281366188

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H,W = map(int,input().split()) grid = [[0]*W]*H for h in range(H): row = input.split() for w,r in enumerate(row): if r == "#": if h>=1: grid[h-1][w] += 1 if w>=1: grid[h-1][w-1] += 1 if w<=W-1: grid[h-1][w+1] += 1 if h<=H-1: grid[h+1][w] += 1 if w>=1: grid[h+1][w-1] += 1 if w<=W-1: grid[h+1][w+1] += 1 if w>=1: grid[h][w-1] +=1 if w<=W-1: grid[h][w+1] +=1 grid.append([0 if v == "." else "#" for v in input().split()]) for g in grid: print("".join([str(v) for v in g])

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s580345704

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H, W = map(int, input().split()) INPUT = [list(input()) for i in range(H)] OUTPUT = INPUT.copy() for i in range(H): for j in range(W): if INPUT[i][j] == '#': OUTPUT[i][j] = '#'a else: OUTPUT[i][j] = 0 for I in (i-1, i, i+1): if not (I < 0 or H <= I): for J in (j-1, j, j+1): if not (J < 0 or W <= J): if INPUT[I][J] == '#': OUTPUT[i][j] += 1 for i in range(H): print(''.join(map(str, OUTPUT[i])))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s658692187

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w=map(int,input().split()) list2=[[0 for i in range(w)]for j in range(h)] list1 = [for _ in range(h) input().split()[] dx=[-1,-1,-1,0,0,1,1,1] dy=[-1,0,1,-1,1,-1,0,1] for j in range(h): for i in range(w): if list1[j][i]=="#": for k in range(8): xk=i+dx[k] yk=j+dy[k] if xk>=0 and xk<w and yk>=0 and yk<h: list2[yk][xk]+=1 for j in range(h): for i in range(w): if list1[j][i]=="#": list2[j][i]="#" else: list2[j][i]=str(list2[j][i]) for j in range(h): print("".join(list2[j]))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s976432193

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w = map(int, input().split()) Array = [list(map(int, input().split())) for _ in range(h)] dx = [1,1,0,-1,-1,-1,0,1] dy = [0,1,1,1,0,-1,-1,-1] for i in range(h): for j in range(w): if Array[i][j]='#': continue num=0 for d in range(8): ni = i+dy[d] nj = j+dx[d] if ni<0 or h<=ni: continue if nj<0 or w<=nj: continue if Array[ni][nj]=='#': num=num+1 Array[i][j]=char(num + '0') for i in Array: print(*Array)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s404153713

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

a, b = [int(input()) for i in range(2)] c = [str(input()) for i in range(a)] for i in range(a): c[i] = "." + c[i] + "." c = ["." * (b + 2)] + c + ["." * (b + 2)] d = [["0" for i in range(b)] for j in range(a)] for i in range(1, a + 1): for j in range(1, b + 1): f = 0 for k in range(-1, 2): for l in range(-1, 2): if c[i + k][j + l] == "#": f += 1 d[i - 1][j - 1] = str(f) for i in range(1, a + 1): for j in range(1, b + 1): if c[i][j] == "#": d[i - 1][j - 1] = "#" for i in range(a): dd = "" for j in range(b): dd += str(d[i][j]) print(dd)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s030274912

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

3 5 ##### ##### #####h, w = map(int, input().split()) field = [["" for _ in range(w)] for _ in range(h)] for i in range(h): s = input() for j in range(w): field[i][j] = s[j] dx = [1, 1, 0, -1, -1, -1, 0, 1] dy = [0, 1, 1, 1, 0, -1, -1, -1] def numbering(x, y): if field[y][x] == ".": c = 0 for i in range(8): nx = x + dx[i] ny = y + dy[i] if 0 <= nx and nx < w and 0 <= ny and ny < h: if field[ny][nx] == "#": c += 1 field[y][x] = str(c) for X in range(w): for Y in range(h): numbering(X, Y) for Y in range(h): for X in range(w): print(field[Y][X], end = "") print()

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s116077072

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

# -*- coding:utf-8 -*- H,W=map(int,input().split()) boxes=list() boxes[0]=[0]*W boxes[H+1]=[0]*W for i in range(H): boxes[i+1]=list() boxes[i+1][0]=0 bowes[i+1][W+1]=0 x=input() for j in range(W): if x[j]=='.': boxes[i+1][j+1]=0 elif x[j]=='#': boxes[i+1][j+1]=1 answer=list() for n in range(H): answer[n]=list() for k in range(W): count=0 if boxes[n][k]==1: count+=1 if boxes[n][k+1]==1: count+=1 if boxes[n][k+2]==1: count+=1 if boxes[n+1][k]==1: count+=1 if boxes[n+1][k+2]==1: count+=1 if boxes[n+2][k]==1: count+=1 if boxes[n+2][k+1]==1: count+=1 if boxes[n+2][k+2]==1: count+=1 if count==0: answer[n][k]='#' else: answer[n][k]=str(count) for v in range(H): answe=''.join(answer[v]) print(answe)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s587642569

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H,W=map(int,input().split()) s=[list(input()) for i in range(H)] for i in range(H): ans=[0]*W for i in range(W): if s[i][j]=="#": ans[j]=="#" continue count=0 if i > 0: if s[i-1][j]=="#": count+=1 if j > 0: if s[i-1][j-1]=="#": count+=1 if j < W-1: if s[i-1][j+1]=5"#": count+=1 if i<H-1: if s[i+1][j]=="#": count+=1 if j >0: if s[i+1][j-1]=="#": count+=1 if j<W-1: if s[i+1][j+1]=="#": count+=1 if j>0: if s[i][j-1]==”#”: count+=1 if j<W-1: if s[i][j+1]=="#": count+=1 ans[j]=count print("".join(map(str,ans)))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s177079529

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w = map(int,input().split()) Array = [list(map(int,input())) for _ in range(h)] dx = [1,1,0,-1,-1,-1,0,1] dy = [0,1,1,1,0,-1,-1,-1] for i in range(h): for j in range(w): if Array[i][j]='#': continue num=0 for d in range(8): ni = i+dy[d] nj = j+dx[d] if ni<0 or h<=ni: continue if nj<0 or w<=nj: continue if Array[ni][nj]=='#': num=num+1 Array[i][j]=char(num) for i in Array: print(i)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s404276994

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w=map(int,input().split()) mapdata=[] result=[] k=[] def get_bomb(i,j): count=0 for x in (i-1.i,i+1): for y in (j-1,j,j+1): if 0<=x<=h-1 and 0<=y<=w-1: if mapdata[x][y]=='#': count+=1 return count for i in range(h): line=list(input()) mapdata.append(line) for i in range(h): for j in range(w): if mapdata[i][j]=='.': k.append(get_bomb(i,j)) else: k.append('#') result.append(k) k=[] for i in range(len(result)): print(result[i])

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s079442397

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

a

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s973646511

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w = map(int,input().split()) Array = [list(map(int,input().split())) for _ in range(h)] dx = [1,1,0,-1,-1,-1,0,1] dy = [0,1,1,1,0,-1,-1,-1] for i in range(h): for j in range(w): if Array[i][j]='#': continue num=0 for d in range(8): ni = i+dy[d] nj = j+dx[d] if ni<0 or h<=ni: continue if nj<0 or w<=nj: continue if Array[ni][nj]=='#': num=num+1 Array[i][j]=char(num) for i in Array: print(*Array)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s963165054

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w = int(input()) Array = [list(map(int, input().split())) for _ in range(h)] dx = [1,1,0,-1,-1,-1,0,1] dy = [0,1,1,1,0,-1,-1,-1] for i in range(h): for j in range(w): if Array[i][j]='#': continue num=0 for d in range(8): ni = i+dy[d] nj = j+dx[d] if ni<0 or h<=ni: continue if nj<0 or w<=nj: continue if Array[ni][nj]=='#': num=num+1 Array[i][j]=char(num + '0') for i in Array: print(*Array)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s548545569

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w = map(int,input().split()) Array = [list(map(str,input())) for _ in range(h)] dx = [1,1,0,-1,-1,-1,0,1] dy = [0,1,1,1,0,-1,-1,-1] for i in range(h): for j in range(w): if Array[i][j]='#': continue num=0 for d in range(8): ni = i+dy[d] nj = j+dx[d] if ni<0 or h<=ni: continue if nj<0 or w<=nj: continue if Array[ni][nj]=='#': num=num+1 Array[i][j]=str(num) for i in Array: print(*i)

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s778436668

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

# 入力 H,W=map(int,input().split()) l=[] for i in range(H): l.append(list(input())) for i in range(H): for j in range(W): # 地雷数のカウンタ c=0 # '#'の場合はなにもしない if l[i][j]=='#': pass # '#'以外の場合 else: # 左上 if 0<i and 0<j and l[i-1][j-1]=='#': c+=1 # 上 if 0<i and l[i-1][j]=='#': c+=1 # 右上 if 0<i and j<W-1 and l[i-1][j+1]=='#': c+=1 # 左 if 0<j and l[i][j-1]=='#': c+=1 # 右 if j<W-1 and l[i][j+1]=='#': c+=1 # 左下 if i<H-1 and 0<j and l[i+1][j-1]=='#': c+=1 # 下 if i<H-1 and l[i+1][j]=='#': c+=1 # 右下 if i<H-1 and j<W-1 and l[i+1][j+1]=='#': c+=1 # 地雷隣接数を記載 l[i][j]=str(c) # 出力 for i in range(H): print(''.join(l[i]))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s818696611

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h = int(input()) w = int(input()) s = list(input() for i in range(1,h+1) number = [] cnt = 0 for i in range(1,h+1) : if i != 1 and i != h : for j in range(1,w+1) : if j != 1 and j != w : number = [s[i-1][j-1],s[i-1][j],s[i-1][j+1],s[i][j-1],s[i][j+1],s[i+1][j-1],s[i+1][j],s[i+1][j+1]] cnt = number.count('#') s[i][j] = cnt elif i == 1 : for j in range(1,w+1) : if j != 1 and j != w : number = [s[i-1][j-1],s[i-1][j],s[i-1][j+1],s[i][j-1],s[i][j+1],s[i+1][j-1],s[i+1][j],s[i+1][j+1]] cnt = number.count('#') s[i][j] = cnt elif j == 1 : number = [s[1][2],s[2][1],s[2][2]] cnt = number.count('#') s[1][1] = cnt elif j == w : number = [s[1][w-1],s[2][w-1],s[2][w]] cnt = number.count('#') s[1][w] = cnt elif i == h : for j in range(1,w+1) : if j == 1 : number = [s[h-1][1],s[h-1][2],s[h][2]] cnt = number.count('#') s[h][1] = cnt elif j == w : number = [s[h-1][w-1],s[h-1][w],s[h][w-1]] cnt = number.count('#') s[h][w] = cnt print(''.join(s))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s860796494

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h,w=map(int,input().split()) s=[list(input()) for _ in range(h)] for i in range(h): for j in range(w): if i==0: if j==0 and s[0][0]=='.': l1=[s[0][1],s[1][0],s[1][1]] l1l=l1.count('#') s[0][0]=l1l elif j==w-1 and s[0][w-1]=='.': r1=[s[0][w-2],s[1][w-2],s[1][w-1]] r1r=r1.count('#') s[0][w-1]=r1r elif j!=0 and j!=w-1 and s[0][j]=='.': l1j=[s[0][j-1],s[0][j+1],[s[1][j-1],s[1][j],s[1][j+1]] l1jj=l1j.count('#') s[0][j]==l1jj else:pass elif i==h-1: if j==0 and s[h-1][0]=='.': lh=[s[h-1][1],s[h-2][0],s[h-2][1]] lhl=lh.count('#') s[h-1][0]=lhl elif j==w-1 and s[h-1][w-1]=='.': rh=[s[h-1][w-2],s[h-2][w-2],s[h-2][w-1]] rhr=rh.count('#') s[h-1][w-1]=rhr elif j!=0 and j!=w-1 and s[h-1][j]=='.': lhj=[s[h-1][j-1],s[h-1][j+1],[s[h-2][j-1],s[h-2][j],s[h-2][j+1]] lhjj=lhj.count('#') s[0][j]==lhjj else:pass else: if j==0 and s[i][0]=='.': li=[s[i-1][0],s[i-1][1],s[i][1],s[i+1][1],s[i+1][0]] lil=li.count('#') s[i][0]=lil elif j==w-1 and s[i][w-1]=='.': ri=[s[i-1][w-1],s[i-1][w-2],s[i][w-1],s[i+1][w-2],s[i+1][w-1]] rir=ri.count('#') s[i][w-1]=rir elif j!=0 and j!=w-1 and s[i][j]=='.': lij=[s[i-1][j-1],s[i-1][j],s[i-1][j+1],s[i][j-1],s[i][j+1],s[i+1][j-1],s[i+1][j],s[i+1][j+1]] lijj=lij.count('#') s[i][j]==lijj else:pass print("".join(s[i]))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s981273822

Accepted

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

H, W = map(int, input().split()) S = ["."] * (W + 2) i = 0 while i < H: S += ["."] + list(input()) + ["."] i += 1 S += ["."] * (W + 2) j = W + 3 while j <= (W + 2) * (H + 1) - 2: count = 0 if S[j] != "#": if S[j - (W + 3)] == "#": count += 1 if S[j - (W + 2)] == "#": count += 1 if S[j - (W + 1)] == "#": count += 1 if S[j - 1] == "#": count += 1 if S[j + 1] == "#": count += 1 if S[j + (W + 1)] == "#": count += 1 if S[j + (W + 2)] == "#": count += 1 if S[j + (W + 3)] == "#": count += 1 S[j] = str(count) j += 1 k = 1 while k <= H: print("".join(S[k * (W + 2) + 1 : k * (W + 2) + 1 + W])) k += 1

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the H strings after the process. The i-th line should contain a string T_i of length W, where the j-th character in T_i corresponds to the square at the i-th row from the top and j-th row from the left in the grid (1 \leq i \leq H, 1 \leq j \leq W). * * *

s871212800

Runtime Error

p03574

Input is given from Standard Input in the following format: H W S_1 : S_H

h, w = map(int, input().split()) s = [0] * h for i in range(h): s[i] = str(input()) t = [[0] * w] * h for j in range(h): if j == 0: for k in range(w): if k == 0: u = s[0][1] + s[1][0] + s[1][1] elif k == w - 1: u = s[0][k - 1] + s[1][k - 1] + s[1][k] else: u = s[0][k - 1] + s[0][k + 1] + s[1][k - 1] + s[1][k] + s[1][k + 1] v = u.count("#") if s[j][k] == "#": v = "#" t[j][k] = str(v) elif j == h - 1: for k in range(w): if k == 0: u = s[j][1] + s[j - 1][0] + s[j - 1][1] elif k == w - 1: u = s[j][k - 1] + s[j - 1][k - 1] + s[j - 1][k] else: u = ( s[j][k - 1] + s[j][k + 1] + s[j - 1][k - 1] + s[j - 1][k] + s[j - 1][k + 1] ) v = u.count("#") if s[j][k] == "#": v = "#" t[j][k] = str(v) else: for k in range(w): if k == 0: u = s[j][1] + s[j - 1][0] + s[j - 1][1] + s[j + 1][0] + s[j + 1][1] elif k == w - 1: u = ( s[j][k - 1] + s[j - 1][k - 1] + s[j - 1][k] + s[j + 1][k - 1] + s[j + 1][k] ) else: u = ( s[j][k - 1] + s[j][k + 1] + s[j - 1][k - 1] + s[j - 1][k] + s[j - 1][k + 1] + s[j + 1][k - 1] + s[j + 1][k] + s[j + 1][k + 1] ) v = u.count("#") if s[j][k] == "#": v = "#" t[j][k] = str(v) print("".join(t[j]))

Statement You are given an H × W grid. The squares in the grid are described by H strings, S_1,...,S_H. The j-th character in the string S_i corresponds to the square at the i-th row from the top and j-th column from the left (1 \leq i \leq H,1 \leq j \leq W). `.` stands for an empty square, and `#` stands for a square containing a bomb. Dolphin is interested in how many bomb squares are horizontally, vertically or diagonally adjacent to each empty square. (Below, we will simply say "adjacent" for this meaning. For each square, there are at most eight adjacent squares.) He decides to replace each `.` in our H strings with a digit that represents the number of bomb squares adjacent to the corresponding empty square. Print the strings after the process.

[{"input": "3 5\n .....\n .#.#.\n .....", "output": "11211\n 1#2#1\n 11211\n \n\nFor example, let us observe the empty square at the first row from the top and\nfirst column from the left. \nThere is one bomb square adjacent to this empty square: the square at the\nsecond row and second column. \nThus, the `.` corresponding to this empty square is replaced with `1`.\n\n* * *"}, {"input": "3 5\n #####\n #####\n #####", "output": "#####\n #####\n #####\n \n\nIt is possible that there is no empty square.\n\n* * *"}, {"input": "6 6\n #####.\n #.#.##\n ####.#\n .#..#.\n #.##..\n #.#...", "output": "#####3\n #8#7##\n ####5#\n 4#65#2\n #5##21\n #4#310"}]

Print the maximum value taken by x during the operations. * * *

s882298998

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

N = int(input()) S = input() a = 0 sum_a = 0 for i in range(N): if S[i]=="I": sum_a += 1 a = max (a , sum_a) else: sum_a- = 1 print(a)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s846352591

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n =int(input()) s = input() x = 0 for i in s: if i ="I": x =max(x,x+1) else: x =max(x,x-1) print(x)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s939032996

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = int(input()) s = input() x = 0 ans = 0 for c in s: if c=='I' x+=1 ans = max(x,ans) else: x-=1 print(ans)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s761704649

Accepted

p03827

The input is given from Standard Input in the following format: N S

import sys, collections as cl, bisect as bs sys.setrecursionlimit(100000) input = sys.stdin.readline mod = 10**9 + 7 Max = sys.maxsize def l(): # intのlist return list(map(int, input().split())) def m(): # 複数文字 return map(int, input().split()) def onem(): # Nとかの取得 return int(input()) def s(x): # 圧縮 a = [] if len(x) == 0: return [] aa = x[0] su = 1 for i in range(len(x) - 1): if aa != x[i + 1]: a.append([aa, su]) aa = x[i + 1] su = 1 else: su += 1 a.append([aa, su]) return a def jo(x): # listをスペースごとに分ける return " ".join(map(str, x)) def max2(x): # 他のときもどうように作成可能 return max(map(max, x)) def In(x, a): # aがリスト(sorted) k = bs.bisect_left(a, x) if k != len(a) and a[k] == x: return True else: return False def pow_k(x, n): ans = 1 while n: if n % 2: ans *= x x *= x n >>= 1 return ans """ def nibu(x,n,r): ll = 0 rr = r while True: mid = (ll+rr)//2 if rr == mid: return ll if (ここに評価入れる): rr = mid else: ll = mid+1 """ n = onem() po = input()[:-1] ma = 0 co = 0 for a in po: if a == "I": co += 1 else: co -= 1 ma = max(ma, co) print(ma)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s737814010

Accepted

p03827

The input is given from Standard Input in the following format: N S

from sys import stdin def fetch_one_line(): return stdin.readline().rstrip() def fetch_int_input(): return [int(s) for s in fetch_one_line().split()] def fetch_inputs(times): return [fetch_one_line() for _ in range(times)] def fetch_int_inputs(times): return [[int(s) for s in fetch_one_line()] for _ in range(times)] sum = 0 change = {"I": 1, "D": -1} length = int(fetch_one_line()) target = fetch_one_line() records = [0 for _ in range(length)] for i, t in enumerate(target): sum += change[t] records[i] = sum max_val = max(records) if max_val < 0: max_val = 0 print(max_val)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s909984386

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

N = int(input()) S = input() x = 0 max = 0 for i in range(N): if S[i] == ‘I’: x += 1 else: x -= 1 if x > max: max = x print(max)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s892194336

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = int(input()) s = input() ans = 0 cur = 0 for c in s: if c == 'I': cur += 1 ans = max(ans, cur) else: cur -= 1 print(ans)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s887194392

Accepted

p03827

The input is given from Standard Input in the following format: N S

# -*- coding: utf-8 -*- import sys from collections import defaultdict, deque # def input(): return sys.stdin.readline()[:-1] # warning not \n # def input(): return sys.stdin.buffer.readline()[:-1] def solve(): n = int(input()) s = input() cnt = 0 ans = 0 for e in s: if e == "I": cnt += 1 else: cnt -= 1 ans = max(ans, cnt) print(ans) t = 1 # t = int(input()) for case in range(1, t + 1): ans = solve() """ 1 4 7 RRRR 1 1 0 1 ---- 4 1 4 47 RCRR 1 1 0 1 ---- -1 2 2 10 RR RR 1 7 4 1 ---- 4 2 2 10 RR RR 7 4 7 4 ---- -1 3 3 8 RCR RRC RRR 1 1 1 1 1 1 1 3 1 3 3 1 RCR RRC RRR 1 1 1 1 1 1 1 3 1 """

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s235388159

Accepted

p03827

The input is given from Standard Input in the following format: N S

import sys input = sys.stdin.readline sys.setrecursionlimit(10**7) from collections import Counter, deque from collections import defaultdict from itertools import combinations, permutations, accumulate, groupby, product from bisect import bisect_left, bisect_right from heapq import heapify, heappop, heappush from math import floor, ceil from operator import itemgetter def I(): return int(input()) def MI(): return map(int, input().split()) def LI(): return list(map(int, input().split())) def LI2(): return [int(input()) for i in range(n)] def MXI(): return [[LI()] for i in range(n)] def printns(x): print("\n".join(x)) def printni(x): print("\n".join(list(map(str, x)))) inf = 10**17 mod = 10**9 + 7 # s=input().rstrip() sm = 0 n = I() mx = 0 s = input().rstrip() for i in range(n): if s[i] == "I": sm += 1 else: sm -= 1 if sm > mx: mx = sm print(mx)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s316999240

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

_ = input() S = input() max_n = 0 temp = 0 for s in S: temp += 1 if s == 'I' else temp -= 1 if max_n < temp: max_n = temp print(max_n)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s959987127

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = int(input()) s = list(map(lambda x: 1 if x == "I" else -1, list(input())) x = 0 m = 0 for i in s: x += i m = max(m,x) print(m)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s735355590

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

S=input() max_v =0 v =0 for i in S: if i=="I": v+=1 if v>max_v: max_v=v else: v-=

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s990317435

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n=int(input()) s=list(input()) k=[0] for i in range(0,n): if s[i]=='I':k.append(int(k[i]+1) else:k.append(int(k[i]-1)) print(max(k))

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s172169867

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = input() s = input() x = 0 y = 0 for i in range(n): if s[i] == "I": y += 1 x = max(x,y) if s[i] == "D": y = y - 1 x = max(x,y) print(x)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s838587918

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

l=[] x=0 l.append(x) n=int(input()) s=input() for i in s: if(i=='I'): x++ l.append(x) if(i=='D'): x-- l.append(x) print(max(l))

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s001119287

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = int(input()) s = input() x = 0 l = [0] for n in range(n): if s[n] == "I": x += 1 l.append(x) else: x -= 1 l.append(x) print(max(l))

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s977856571

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

l=[] x=0 l.append(x) n=int(input()) s=input() for i in s: if(i=='I'): x++ l.append(x) if(i=='D'): x-- l.append(x) print(max(l))

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s020350300

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

N = int(input()) line = input() x = 0 t = 0 for i in range(N): if line[i] == 'I': t += 1 else if line[i] == 'D': t -= 1 x = max(t,x) print(x)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s773479044

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = int(input()) s = input() x = 0 l = [0] for i in range(n): if s[i] == "I": x += 1 l.append(x) else: x -= 1 l.append(x) print(max(l))

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s423621683

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

N = int(input()) S = input() ans = 0 x = 0 for s in S: v = 1 if s == 'I' else: 0 x += v ans = max(ans, x) print(ans)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s079991453

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

i = int(input()) s = input() ans = 0 for x in range(len(i)) : if s[x] == "I" : ans ++ else : ans -- print(ans)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s332798043

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

N=int(input()) S=input() ans=0 cnt=0 for i in range(N): if S[i]='I': cnt+=1 ans=max(cnt,ans) else: cnt-=1 print(ans)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s486276912

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n=int(input()) s=input() ans=0 x=0 for i in range(n): if s[i]=='I': ans+=1 x=max(0,ans) else: ans-=1 print(x)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s474201501

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = int(input()) s = list(input()) for i in s: if i =="I": n += 1 else: n -= 1 print(n)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s000317804

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = int(input()) s = input() x = m = 0 for i range(n): x += [-1,1][s[i] == I]; m = max(m,x) print(m)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s010790292

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

N = int(input()) S = list(input()) x = 0 for item in S: if item == 'I": x+= 1 if item == 'D': x-= 1

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s112938253

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

n = input() s = input() x = 0 y = 0 for i in range(len(s)): if s[i] == "I": y += 1 x = max(x,y) if s[i] == "D": y = y - 1 x = max(x,y) print(x)

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s953206439

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

def main(): n = int(input()) s = list(input().split()) ans = 0 now = 0 for i, i_d in enumerate(s): if i_d == 'I': now += 1 ans = max(ans, now) else: now -= 1 print(ans) if __name__ = '__main__': main()

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s810631791

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

# ABC052B - Increment Decrement def main(): _, S = tuple(input() for _ in range(2)) ans, x = [0], 0 for i in S: x += 1 i == "I" else -1 ans += [x] print(max(ans)) if __name__ == "__main__": main()

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the maximum value taken by x during the operations. * * *

s631890812

Runtime Error

p03827

The input is given from Standard Input in the following format: N S

= int(input()) S = str(input()) cnt = 0 ans = [] for i in range(0,N): if S[i] == "I": cnt = cnt+1 elif S[i] == "D": cnt = cnt-1 ans.append(cnt) if max(ans) <= 0: print("0") else: print(max(ans))

Statement You have an integer variable x. Initially, x=0. Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`. Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).

[{"input": "5\n IIDID", "output": "2\n \n\nAfter each operation, the value of x becomes 1, 2, 1, 2 and 1, respectively.\nThus, the output should be 2, the maximum value.\n\n* * *"}, {"input": "7\n DDIDDII", "output": "0\n \n\nThe initial value x=0 is the maximum value taken by x, thus the output should\nbe 0."}]

Print the minimum number of operations needed. * * *

s091173378

Accepted

p02735

Input is given from Standard Input in the following format: H W s_{11} s_{12} \cdots s_{1W} s_{21} s_{22} \cdots s_{2W} \vdots s_{H1} s_{H2} \cdots s_{HW} Here s_{rc} represents the color of (r, c) \- `#` stands for black, and `.` stands for white.

import copy H, W = map(int, input().split()) root_list = [] for _ in range(H): root_list.append(list(str(input()))) change_list = copy.deepcopy(root_list) DP_list = [] for i, line in enumerate(root_list): DP_line = [] str_pt = root_list[i][0] if i == 0: DP_line.append(0) # 初期値 else: if root_list[i - 1][0] == line[0]: # 1文字目が上下一致 DP_line.append(DP_list[i - 1][0]) else: DP_line.append(DP_list[i - 1][0] + 1) for j, pt in enumerate(line[1:], 1): # 先頭は抜かす if i == 0: # 1行目 if str_pt == pt: # 前の文字と一致 DP_line.append(DP_line[j - 1]) # 前の値を入れる else: DP_line.append(DP_line[j - 1] + 1) # 違ったら1足す str_pt = pt else: # 2行目以降（上下左右比較） # 横比較 if str_pt == pt: yoko_pt = DP_line[j - 1] else: yoko_pt = DP_line[j - 1] + 1 # 縦比較 if pt == root_list[i - 1][j]: tate_pt = DP_list[i - 1][j] else: tate_pt = DP_list[i - 1][j] + 1 DP_line.append(min(yoko_pt, tate_pt)) str_pt = pt DP_list.append(DP_line) result = DP_list[H - 1][W - 1] // 2 if root_list[0][0] == "#": result += 1 if root_list[H - 1][W - 1] == "#": result += 1 if root_list[0][0] == "#" and root_list[H - 1][W - 1] == "#": if result == 2 or (H == 1 and W == 1): result = 1 else: result -= 1 print(result)

Statement Consider a grid with H rows and W columns of squares. Let (r, c) denote the square at the r-th row from the top and the c-th column from the left. Each square is painted black or white. The grid is said to be _good_ if and only if the following condition is satisfied: * From (1, 1), we can reach (H, W) by moving one square **right or down** repeatedly, while always being on a white square. Note that (1, 1) and (H, W) must be white if the grid is good. Your task is to make the grid good by repeating the operation below. Find the minimum number of operations needed to complete the task. It can be proved that you can always complete the task in a finite number of operations. * Choose four integers r_0, c_0, r_1, c_1(1 \leq r_0 \leq r_1 \leq H, 1 \leq c_0 \leq c_1 \leq W). For each pair r, c (r_0 \leq r \leq r_1, c_0 \leq c \leq c_1), invert the color of (r, c) \- that is, from white to black and vice versa.

[{"input": "3 3\n .##\n .#.\n ##.", "output": "1\n \n\nDo the operation with (r_0, c_0, r_1, c_1) = (2, 2, 2, 2) to change just the\ncolor of (2, 2), and we are done.\n\n* * *"}, {"input": "2 2\n #.\n .#", "output": "2\n \n\n* * *"}, {"input": "4 4\n ..##\n #...\n ###.\n ###.", "output": "0\n \n\nNo operation may be needed.\n\n* * *"}, {"input": "5 5\n .#.#.\n #.#.#\n .#.#.\n #.#.#\n .#.#.", "output": "4"}]