description stringlengths 171 4k | code stringlengths 94 3.98k | normalized_code stringlengths 57 4.99k |
|---|---|---|
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | l = list(map(int, input().split()))
l.insert(0, 0)
c1 = [
1,
6,
3,
8,
5,
10,
7,
12,
9,
23,
11,
21,
13,
14,
15,
16,
17,
18,
19,
20,
4,
22,
2,
24,
]
c2 = [
1,
23,
3,
21,
5,
2,
7,
4,
9,
6,
11,
8,
13,
14,
15,
16,
17,
18,
19,
20,
12,
22,
10,
24,
]
c3 = [
1,
2,
3,
4,
5,
6,
15,
16,
9,
10,
11,
12,
13,
14,
23,
24,
17,
18,
7,
8,
21,
22,
19,
20,
]
c4 = [
1,
2,
3,
4,
5,
6,
19,
20,
9,
10,
11,
12,
13,
14,
7,
8,
17,
18,
23,
24,
21,
22,
15,
16,
]
c5 = [
1,
2,
16,
14,
5,
6,
7,
8,
19,
17,
11,
12,
13,
9,
15,
10,
3,
18,
4,
20,
21,
22,
23,
24,
]
c6 = [
1,
2,
17,
19,
5,
6,
7,
8,
14,
16,
11,
12,
13,
4,
15,
3,
10,
18,
9,
20,
21,
22,
23,
24,
]
flag = 0
mark = 0
for i in range(6):
if l[c1[4 * i]] == l[c1[4 * i + 1]] == l[c1[4 * i + 2]] == l[c1[4 * i + 3]]:
mark = 1
else:
mark = 0
break
if mark:
flag = 1
mark = 0
for i in range(6):
if l[c2[4 * i]] == l[c2[4 * i + 1]] == l[c2[4 * i + 2]] == l[c2[4 * i + 3]]:
mark = 1
else:
mark = 0
break
if mark:
flag = 1
mark = 0
for i in range(6):
if l[c3[4 * i]] == l[c3[4 * i + 1]] == l[c3[4 * i + 2]] == l[c3[4 * i + 3]]:
mark = 1
else:
mark = 0
break
if mark:
flag = 1
mark = 0
for i in range(6):
if l[c4[4 * i]] == l[c4[4 * i + 1]] == l[c4[4 * i + 2]] == l[c4[4 * i + 3]]:
mark = 1
else:
mark = 0
break
if mark:
flag = 1
mark = 0
for i in range(6):
if l[c5[4 * i]] == l[c5[4 * i + 1]] == l[c5[4 * i + 2]] == l[c5[4 * i + 3]]:
mark = 1
else:
mark = 0
break
if mark:
flag = 1
mark = 0
for i in range(6):
if l[c6[4 * i]] == l[c6[4 * i + 1]] == l[c6[4 * i + 2]] == l[c6[4 * i + 3]]:
mark = 1
else:
mark = 0
break
if mark:
flag = 1
if flag:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR BIN_OP NUMBER VAR VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR BIN_OP NUMBER VAR VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR BIN_OP NUMBER VAR VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR BIN_OP NUMBER VAR VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR BIN_OP NUMBER VAR VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR BIN_OP NUMBER VAR VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def same(i, j, k, l):
return c[i] == c[j] == c[k] == c[l]
check = [
[
9,
11,
6,
8,
22,
24,
10,
12,
1,
3,
21,
23,
5,
7,
2,
4,
13,
14,
16,
15,
17,
19,
20,
18,
],
[
1,
3,
6,
8,
5,
7,
10,
12,
9,
11,
21,
23,
22,
24,
2,
4,
13,
14,
16,
15,
17,
19,
20,
18,
],
[
13,
14,
7,
8,
5,
6,
19,
20,
17,
18,
23,
24,
21,
22,
15,
16,
1,
2,
3,
4,
9,
10,
11,
12,
],
[
17,
18,
7,
8,
21,
22,
19,
20,
13,
14,
23,
24,
5,
6,
15,
16,
1,
2,
3,
4,
9,
10,
11,
12,
],
[
1,
2,
14,
16,
9,
10,
13,
15,
11,
12,
17,
19,
3,
4,
18,
20,
5,
6,
7,
8,
21,
22,
23,
24,
],
[
11,
12,
14,
16,
3,
4,
13,
15,
1,
2,
17,
19,
9,
10,
18,
20,
5,
6,
7,
8,
21,
22,
23,
24,
],
]
c = [0] + list(map(int, input().split()))
for L in check:
if all(same(*L[i : i + 4]) for i in range(0, 24, 4)):
print("YES")
break
else:
print("NO") | FUNC_DEF RETURN VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | colors = input().strip().split()
rotates = [
[
3,
1,
4,
2,
17,
18,
7,
8,
9,
10,
11,
12,
5,
6,
15,
16,
21,
22,
19,
20,
13,
14,
23,
24,
],
[
5,
2,
7,
4,
9,
6,
11,
8,
24,
10,
22,
12,
14,
16,
13,
15,
17,
18,
19,
20,
21,
3,
23,
1,
],
[
1,
2,
17,
19,
6,
8,
5,
7,
14,
16,
11,
12,
13,
4,
15,
3,
10,
18,
9,
20,
21,
22,
23,
24,
],
]
def is_assembled(cube):
for edge in range(6):
color = cube[edge * 4]
for i in range(1, 4):
if cube[edge * 4 + i] != color:
return False
return True
def rotate(cube, rotation):
new_cube = []
for i in range(len(cube)):
new_cube.append(cube[rotation[i] - 1])
return new_cube
def reverse_rotate(rotatation):
res = 24 * [None]
for FROM, TO in enumerate(rotatation, start=1):
res[TO - 1] = FROM
return res
is_assemblible = False
for rot in rotates:
if is_assembled(rotate(colors, rot)) or is_assembled(
rotate(colors, reverse_rotate(rot))
):
is_assemblible = True
break
if is_assemblible:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR BIN_OP BIN_OP VAR NUMBER VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR BIN_OP NUMBER LIST NONE FOR VAR VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR RETURN VAR ASSIGN VAR NUMBER FOR VAR VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = list(map(int, input().split()))
ans = "NO"
pairs = [[1, 9], [5, 21], [13, 17]]
cells = {
(1): [5, 6, 17, 18, 21, 22, 13, 14],
(9): [7, 8, 19, 20, 23, 24, 15, 16],
(5): [9, 10, 19, 17, 4, 3, 14, 16],
(21): [11, 12, 20, 18, 2, 1, 13, 15],
(13): [7, 5, 3, 1, 22, 24, 11, 9],
(17): [8, 6, 4, 2, 21, 23, 12, 10],
}
for i, j in pairs:
if 1 < len(set(a[i - 1 : i + 3])) or 1 < len(set(a[j - 1 : j + 3])):
continue
ci = cells[i]
cj = cells[j]
for d in [2, 6]:
f = True
for k in range(0, 8, 2):
if a[ci[k] - 1] != a[ci[(k + 1) % 8] - 1]:
f = False
if a[cj[k] - 1] != a[cj[(k + 1) % 8] - 1]:
f = False
if a[ci[k] - 1] != a[cj[(k + d) % 8] - 1]:
f = False
if f:
ans = "YES"
print(ans) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR STRING ASSIGN VAR LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR VAR VAR IF NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR FOR VAR LIST NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR STRING EXPR FUNC_CALL VAR VAR |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = [int(w) for w in input().split()]
cycles = [
[5, 6, 17, 18, 21, 22, 13, 14],
[9, 10, 19, 17, 4, 3, 14, 16],
[8, 7, 16, 15, 24, 23, 20, 19],
[7, 5, 3, 1, 22, 24, 11, 9],
[6, 8, 10, 12, 23, 21, 2, 4],
[18, 20, 12, 11, 15, 13, 1, 2],
]
cycles = [[(i - 1) for i in cycle] for cycle in cycles]
cycles += [list(reversed(cycle)) for cycle in cycles]
def rotate(a, cycle):
b = a[:]
for i in range(8):
b[cycle[(i + 2) % 8]] = a[cycle[i]]
return b
def ordered(a):
for side in range(6):
if not a[side * 4] == a[side * 4 + 1] == a[side * 4 + 2] == a[side * 4 + 3]:
return False
return True
for cycle in cycles:
if ordered(rotate(a, cycle)):
print("YES")
break
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR NUMBER VAR VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR FUNC_DEF ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR VAR VAR RETURN VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR NUMBER NUMBER RETURN NUMBER RETURN NUMBER FOR VAR VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | l = [0] + [int(i) for i in input().split(" ")]
if l[13] == l[14] == l[15] == l[16] and l[17] == l[18] == l[19] == l[20]:
if (
l[5] == l[7] == l[10] == l[12]
and l[9] == l[11] == l[21] == l[23]
and l[1] == l[3] == l[6] == l[8]
and l[2] == l[4] == l[22] == l[24]
):
print("YES")
exit(0)
if (
l[5] == l[7] == l[2] == l[4]
and l[9] == l[11] == l[6] == l[8]
and l[1] == l[3] == l[21] == l[23]
and l[10] == l[12] == l[22] == l[24]
):
print("YES")
exit(0)
if l[1] == l[2] == l[3] == l[4] and l[9] == l[10] == l[11] == l[12]:
if (
l[5] == l[6] == l[19] == l[20]
and l[17] == l[18] == l[23] == l[24]
and l[21] == l[22] == l[15] == l[16]
and l[13] == l[14] == l[7] == l[8]
):
print("YES")
exit(0)
if (
l[5] == l[6] == l[15] == l[16]
and l[13] == l[14] == l[23] == l[24]
and l[21] == l[22] == l[19] == l[20]
and l[17] == l[18] == l[7] == l[8]
):
print("YES")
exit(0)
if l[5] == l[6] == l[7] == l[8] and l[21] == l[22] == l[23] == l[24]:
if (
l[3] == l[4] == l[18] == l[20]
and l[17] == l[19] == l[11] == l[12]
and l[9] == l[10] == l[13] == l[15]
and l[14] == l[16] == l[1] == l[2]
):
print("YES")
exit(0)
if (
l[3] == l[4] == l[13] == l[15]
and l[14] == l[16] == l[11] == l[12]
and l[9] == l[10] == l[18] == l[20]
and l[17] == l[19] == l[1] == l[2]
):
print("YES")
exit(0)
print("NO") | ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = list(map(int, input().split()))
def magic(b):
for i in range(4):
if not b[i * 4] == b[i * 4 + 2] == b[(i * 4 + 5) % 16] == b[(i * 4 + 7) % 16]:
break
else:
print("YES")
return
for i in range(4):
if (
not b[4 * i + 1]
== b[4 * i + 3]
== b[(4 * i + 4) % 16]
== b[(4 * i + 6) % 16]
):
break
else:
print("YES")
return
print("NO")
return
if a[0] == a[2] == a[3] == a[1] and a[8] == a[10] == a[11] == a[9]:
magic(
[
a[14],
a[12],
a[15],
a[13],
a[6],
a[4],
a[7],
a[5],
a[18],
a[16],
a[19],
a[17],
a[22],
a[20],
a[23],
a[21],
]
)
elif a[12] == a[14] == a[15] == a[13] and a[16] == a[18] == a[17] == a[19]:
magic(a[:12] + a[23:19:-1])
elif a[4] == a[6] == a[7] == a[5] and a[20] == a[22] == a[23] == a[23]:
magic(
[
a[2],
a[0],
a[3],
a[1],
a[16],
a[17],
a[18],
a[19],
a[9],
a[11],
a[8],
a[10],
a[15],
a[14],
a[13],
a[12],
]
)
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR STRING RETURN FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP BIN_OP NUMBER VAR NUMBER NUMBER VAR BIN_OP BIN_OP BIN_OP NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR STRING RETURN EXPR FUNC_CALL VAR STRING RETURN IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER VAR NUMBER NUMBER NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | from sys import stdin
s = list(map(int, stdin.readline().strip().split()))
l1 = [s[0], s[2], s[4], s[6], s[8], s[10], s[-3], s[-1]]
l2 = [s[1], s[3], s[5], s[7], s[9], s[11], s[-4], s[-2]]
l3 = [s[12], s[13], s[4], s[5], s[16], s[17], s[20], s[21]]
l4 = [s[14], s[15], s[6], s[7], s[18], s[19], s[22], s[23]]
l5 = [s[0], s[1], s[17], s[19], s[11], s[10], s[14], s[12]]
l6 = [s[2], s[3], s[16], s[18], s[9], s[8], s[15], s[13]]
t1 = True
t12 = True
t2 = False
t32 = True
t3 = True
t4 = False
t5 = True
t52 = True
t6 = False
for i in range(2, 8 + 2):
if l1[i % 8] != l2[i - 2]:
t1 = False
for i in range(6, 8 + 6):
if l1[i % 8] != l2[i - 6]:
t12 = False
if (
l3[0] == l4[0]
and l3[1] == l4[1]
and l3[0] == l3[1]
and l3[4] == l4[4]
and l3[5] == l4[5]
and l3[4] == l3[5]
):
t2 = True
for i in range(2, 8 + 2):
if l3[i % 8] != l4[i - 2]:
t3 = False
for i in range(6, 8 + 6):
if l3[i % 8] != l4[i - 6]:
t32 = False
if (
l1[0] == l2[0]
and l1[1] == l2[1]
and l1[0] == l1[1]
and l1[4] == l2[4]
and l1[5] == l2[5]
and l1[4] == l1[5]
):
t4 = True
for i in range(2, 8 + 2):
if l5[i % 8] != l6[i - 2]:
t5 = False
for i in range(6, 8 + 6):
if l5[i % 8] != l6[i - 6]:
t52 = False
if (
l1[2] == l2[2]
and l1[3] == l2[3]
and l1[2] == l1[3]
and l1[6] == l2[6]
and l1[7] == l2[7]
and l1[6] == l1[7]
):
t6 = True
t3 = t3 or t32
t1 = t1 or t12
t5 = t5 or t52
if t1 and t2 or t3 and t4 or t5 and t6:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER NUMBER IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR IF VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | import sys
def check(h):
for i in range(1, 7):
if h[4 * i - 1] == h[4 * i - 2] == h[4 * i - 3] == h[4 * i - 4]:
c = 1
else:
return False
return True
a = list(map(int, input().split()))
h = [i for i in a]
t = h[20]
w = h[22]
h[20] = h[3]
h[22] = h[1]
p = t
k = w
t = h[9]
w = h[11]
h[9] = p
h[11] = k
p = t
k = w
t = h[5]
w = h[7]
h[5] = p
h[7] = k
p = t
k = w
h[1] = p
h[3] = k
p = t
k = w
if check(h):
print("YES")
sys.exit()
h = [i for i in a]
t = h[1]
w = h[3]
h[1] = h[22]
h[3] = h[20]
p = t
k = w
t = h[5]
w = h[7]
h[5] = p
h[7] = k
p = t
k = w
t = h[9]
w = h[11]
h[9] = p
h[11] = k
p = t
k = w
h[22] = p
h[20] = k
p = t
k = w
if check(h):
print("YES")
sys.exit()
h = [i for i in a]
t = h[12]
w = h[13]
h[12] = h[20]
h[13] = h[21]
p = t
k = w
t = h[4]
w = h[5]
h[4] = p
h[5] = k
p = t
k = w
t = h[16]
w = h[17]
h[16] = p
h[17] = k
p = t
k = w
h[20] = p
h[21] = k
p = t
k = w
if check(h):
print("YES")
sys.exit()
h = [i for i in a]
t = h[14]
w = h[15]
h[14] = h[22]
h[15] = h[23]
p = t
k = w
t = h[6]
w = h[7]
h[6] = p
h[7] = k
p = t
k = w
t = h[18]
w = h[19]
h[18] = p
h[19] = k
p = t
k = w
h[22] = p
h[23] = k
p = t
k = w
if check(h):
print("YES")
sys.exit()
h = [i for i in a]
t = h[2]
w = h[3]
h[2] = h[15]
h[3] = h[13]
p = t
k = w
t = h[16]
w = h[18]
h[16] = p
h[18] = k
p = t
k = w
t = h[8]
w = h[9]
h[8] = k
h[9] = p
p = t
k = w
h[13] = p
h[15] = k
p = t
k = w
if check(h):
print("YES")
sys.exit()
h = [i for i in a]
t = h[2]
w = h[3]
h[2] = h[16]
h[3] = h[18]
p = t
k = w
t = h[13]
w = h[15]
h[13] = k
h[15] = p
p = t
k = w
t = h[8]
w = h[9]
h[8] = p
h[9] = k
p = t
k = w
h[16] = k
h[18] = p
p = t
k = w
if check(h):
print("YES")
sys.exit()
print("NO") | IMPORT FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER ASSIGN VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR ASSIGN VAR NUMBER VAR ASSIGN VAR VAR ASSIGN VAR VAR IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = [int(i) for i in input().split()]
a1 = [[a[j * 4 + i] for i in range(4)] for j in range(6)]
ver = a1[0]
per = a1[1]
niz = a1[2]
lev = a1[3]
prav = a1[4]
zad = a1[5]
res = "NO"
if len(set(lev)) == 1 and len(set(prav)) == 1:
per1 = 1 if per[1] == per[3] else 0
ver1 = 1 if ver[1] == ver[3] else 0
niz1 = 1 if niz[1] == niz[3] else 0
zad1 = 1 if zad[0] == zad[2] else 0
per2 = 1 if per[0] == per[2] else 0
ver2 = 1 if ver[0] == ver[2] else 0
niz2 = 1 if niz[0] == niz[2] else 0
zad2 = 1 if zad[1] == zad[3] else 0
if (
(per1 == ver2 and per[1] == ver[0])
and (ver1 == zad2 and zad[1] == ver[1])
and (zad1 == niz2 and zad[0] == niz[0])
and (niz1 == per2 and per[0] == niz[1])
):
res = "YES"
elif (
(per1 == niz2 and per[1] == niz[0])
and (ver1 == per2 and per[0] == ver[1])
and (zad1 == ver2 and zad[0] == ver[0])
and (niz1 == zad2 and zad[1] == niz[1])
):
res = "YES"
elif len(set(niz)) == 1 and len(set(ver)) == 1:
per1 = 1 if per[0] == per[1] else 0
lev1 = 1 if lev[0] == lev[1] else 0
prav1 = 1 if prav[0] == prav[1] else 0
zad1 = 1 if zad[0] == zad[1] else 0
per2 = 1 if per[2] == per[3] else 0
lev2 = 1 if lev[2] == lev[3] else 0
prav2 = 1 if prav[2] == prav[3] else 0
zad2 = 1 if zad[2] == zad[3] else 0
if (
(per1 == lev2 and per[0] == lev[2])
and (lev1 == zad2 and zad[2] == lev[0])
and (zad1 == prav2 and zad[0] == prav[2])
and (prav1 == per2 and per[2] == prav[0])
):
res = "YES"
elif (
(per1 == prav2 and per[0] == prav[2])
and (prav1 == zad2 and zad[2] == prav[0])
and (zad1 == lev2 and zad[0] == lev[2])
and (lev1 == per2 and per[2] == lev[0])
):
res = "YES"
elif len(set(per)) == 1 and len(set(zad)) == 1:
ver1 = 1 if ver[2] == ver[3] else 0
lev1 = 1 if lev[3] == lev[1] else 0
prav1 = 1 if prav[0] == prav[2] else 0
niz1 = 1 if niz[0] == niz[1] else 0
ver2 = 1 if ver[0] == ver[1] else 0
lev2 = 1 if lev[2] == lev[0] else 0
prav2 = 1 if prav[1] == prav[3] else 0
niz2 = 1 if niz[2] == niz[3] else 0
if (
(ver1 == lev2 and ver[2] == lev[2])
and (lev1 == niz2 and niz[2] == lev[3])
and (niz1 == prav2 and niz[0] == prav[1])
and (prav1 == ver2 and ver[0] == prav[0])
):
res = "YES"
elif (
(ver1 == prav2 and ver[2] == prav[1])
and (prav1 == niz2 and niz[2] == prav[0])
and (niz1 == lev2 and niz[0] == lev[2])
and (lev1 == ver2 and ver[0] == lev[3])
):
res = "YES"
if (
len(set(per)) == 1
and len(set(zad)) == 1
and len(set(niz)) == 1
and len(set(ver)) == 1
and len(set(lev)) == 1
and len(set(prav)) == 1
):
res = "NO"
print(res) | ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR BIN_OP BIN_OP VAR NUMBER VAR VAR FUNC_CALL VAR NUMBER VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR STRING IF FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR STRING IF VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR STRING IF FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR STRING IF VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR STRING IF FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER NUMBER NUMBER IF VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR STRING IF VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER VAR VAR VAR NUMBER VAR NUMBER ASSIGN VAR STRING IF FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR STRING EXPR FUNC_CALL VAR VAR |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | l = list(map(int, input().split()))
U = l[0:4]
F = l[4:8]
D = l[8:12]
L = l[12:16]
R = l[16:20]
B = l[20:24]
if L.count(L[0]) == 4 and R.count(R[0]) == 4:
if (
D[1] == D[3] == F[0] == F[2]
and F[1] == F[3] == U[0] == U[2]
and U[1] == U[3] == B[1] == B[3]
and B[0] == B[2] == D[0] == D[2]
):
print("YES")
elif (
D[1] == D[3] == B[1] == B[3]
and B[0] == B[2] == U[0] == U[2]
and U[1] == U[3] == F[0] == F[2]
and F[1] == F[3] == D[0] == D[2]
):
print("YES")
else:
print("NO")
elif U.count(U[0]) == 4 and D.count(D[0]) == 4:
if (
L[0] == L[1] == F[2] == F[3]
and F[0] == F[1] == R[2] == R[3]
and R[0] == R[1] == B[2] == B[3]
and B[0] == B[1] == L[2] == L[3]
):
print("YES")
elif (
L[0] == L[1] == B[2] == B[3]
and B[0] == B[1] == R[2] == R[3]
and R[0] == R[1] == F[2] == F[3]
and F[0] == F[1] == L[2] == L[3]
):
print("YES")
else:
print("NO")
elif F.count(F[0]) == 4 and B.count(B[0]) == 4:
if (
L[0] == L[2] == U[2] == U[3]
and U[0] == U[1] == R[0] == R[2]
and R[1] == R[3] == D[0] == D[1]
and D[2] == D[3] == L[1] == L[3]
):
print("YES")
elif (
L[0] == L[2] == D[0] == D[1]
and D[2] == D[3] == R[0] == R[2]
and R[1] == R[3] == U[3] == U[2]
and U[0] == U[1] == L[1] == L[3]
):
print("YES")
else:
print("NO")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER IF FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = list(map(int, input().split()))
x, i = 0, 0
w = []
while i < 24:
n = len(set(a[i : i + 4]))
if n == 1:
x += 1
elif n == 2:
w.append(set(a[i : i + 4]))
i += 4
w = set(frozenset(i) for i in w)
print(["NO", "YES"][x == 2 and len(set(w)) == 4]) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR LIST WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR EXPR FUNC_CALL VAR LIST STRING STRING VAR NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | take = list(map(int, input().split()))
big = []
big.append([2, 4, 6, 8, 10, 12, 23, 21])
big.append([1, 3, 5, 7, 9, 11, 24, 22])
big.append([15, 16, 7, 8, 19, 20, 23, 24])
big.append([13, 14, 5, 6, 17, 18, 21, 22])
big.append([3, 4, 17, 19, 10, 9, 16, 14])
big.append([1, 2, 18, 20, 12, 11, 15, 13])
for i in big:
temp1, temp2 = take[:], take[:]
for j in range(0, 8):
temp1[i[j] - 1] = take[i[(j + 2) % 8] - 1]
temp2[i[j] - 1] = take[i[(j + 2) % 8] - 1]
k, l = 0, 0
while k <= 21:
if temp1[k] == temp1[k + 1] == temp1[k + 2] == temp1[k + 3]:
l += 1
k += 4
if l == 6:
print("YES")
exit()
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST EXPR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR VAR ASSIGN VAR VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER WHILE VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | import itertools
import sys
id = """
12
34
ef56ijmn
gh78klop
9a
bc
"""
transforms = [
[[1, 2, 3, 4], [22, 21, 18, 17, 6, 5, 14, 13]],
[[9, 10, 11, 12], [15, 16, 7, 8, 19, 20, 23, 24]],
[[5, 6, 7, 8], [3, 4, 17, 19, 10, 9, 16, 14]],
[[13, 14, 15, 16], [1, 3, 5, 7, 9, 11, 24, 22]],
[[17, 18, 19, 20], [4, 2, 21, 23, 12, 10, 8, 6]],
[[21, 22, 24, 23], [2, 1, 13, 15, 11, 12, 20, 18]],
]
def rot(c, perm, rev):
new = list(c)
if rev:
for i in range(len(perm)):
new[perm[i] - 1] = c[perm[(i + 1) % len(perm)] - 1]
else:
for i in range(len(perm)):
new[perm[(i + 1) % len(perm)] - 1] = c[perm[i] - 1]
return new
def do_t(c, t, rev):
return rot(rot(rot(c, t[0], rev), t[1], rev), t[1], rev)
faces = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16],
[17, 18, 19, 20],
[21, 22, 23, 24],
]
colors = input().split()
for rev, t in itertools.product([0, 1], transforms):
newc = do_t(colors, t, rev)
ok = True
for f in faces:
fc = [newc[i - 1] for i in f]
if fc.count(fc[0]) != 4:
ok = False
if ok:
print("YES")
return
print("NO") | IMPORT IMPORT ASSIGN VAR STRING ASSIGN VAR LIST LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR IF VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR BIN_OP VAR VAR NUMBER RETURN VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR FOR VAR VAR FUNC_CALL VAR LIST NUMBER NUMBER VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR VAR BIN_OP VAR NUMBER VAR VAR IF FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING RETURN EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | original = input().split()
original = [int(x) for x in original]
def transform(T, a):
b = a[:]
for i in range(0, 24):
b[T[i]] = a[i]
return b
def generate_transformation(delta):
ans0 = [x for x in range(0, 24)]
ans1 = [x for x in range(0, 24)]
for k, v in delta.items():
ans0[k - 1] = v - 1
ans1[v - 1] = k - 1
return ans0, ans1
facegroup = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16],
[17, 18, 19, 20],
[21, 22, 23, 24],
]
def check_done(facegroup, faces):
for fg in facegroup:
for cell in fg:
if faces[cell - 1] != faces[fg[0] - 1]:
return False
return True
tl = {
(1): 5,
(3): 7,
(5): 9,
(7): 11,
(9): 24,
(11): 22,
(24): 1,
(22): 3,
(14): 16,
(16): 15,
(15): 13,
(13): 14,
}
tr = {
(2): 6,
(4): 8,
(6): 10,
(8): 12,
(10): 23,
(12): 21,
(23): 2,
(21): 4,
(17): 19,
(19): 20,
(20): 18,
(18): 17,
}
tt = {
(13): 5,
(14): 6,
(5): 17,
(6): 18,
(17): 21,
(18): 2,
(21): 13,
(22): 14,
(1): 3,
(3): 4,
(4): 2,
(2): 1,
}
td = {
(15): 7,
(16): 8,
(7): 19,
(8): 20,
(19): 23,
(20): 24,
(23): 15,
(24): 16,
(9): 10,
(10): 12,
(12): 11,
(11): 9,
}
tf = {
(5): 6,
(6): 7,
(7): 8,
(8): 6,
(14): 9,
(16): 10,
(9): 19,
(10): 17,
(19): 4,
(17): 3,
(4): 14,
(3): 16,
}
tb = {
(23): 21,
(21): 22,
(22): 24,
(24): 23,
(2): 13,
(1): 15,
(13): 11,
(15): 12,
(11): 20,
(12): 18,
(20): 2,
(18): 1,
}
t = [tl, tr, tt, td, tf, tb]
ok = False
for trans in t:
u, v = generate_transformation(trans)
if check_done(facegroup, transform(u, original)):
ok = True
break
if check_done(facegroup, transform(v, original)):
ok = True
break
if ok:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR FUNC_DEF ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR VAR RETURN VAR FUNC_DEF ASSIGN VAR VAR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR NUMBER NUMBER FOR VAR VAR FUNC_CALL VAR ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER RETURN VAR VAR ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER FUNC_DEF FOR VAR VAR FOR VAR VAR IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST VAR VAR VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | n = list(input().split())
def newMap(n, transPair):
new_list = n[:]
for pair in transPair:
new_list[pair[0] - 1] = n[pair[1] - 1]
return new_list
def isOK(n):
for f in range(0, 6):
for i in range(0, 3):
if n[f * 4 + i] != n[f * 4 + i + 1]:
return False
return True
def cal(n):
new = n
for _ in range(0, 4):
new = newMap(
new, [(1, 5), (5, 9), (9, 24), (24, 1), (3, 7), (7, 11), (11, 22), (22, 3)]
)
if _ % 2 == 1:
continue
res = isOK(new)
if res:
print("YES")
return
new = n
for _ in range(0, 4):
new = newMap(
new,
[
(13, 5),
(5, 17),
(17, 21),
(21, 13),
(14, 6),
(6, 18),
(18, 22),
(22, 14),
],
)
if _ % 2 == 1:
continue
res = isOK(new)
if res:
print("YES")
return
new = n
for _ in range(0, 4):
new = newMap(
new,
[(4, 14), (14, 9), (9, 19), (19, 4), (3, 16), (16, 10), (10, 17), (17, 3)],
)
if _ % 2 == 1:
continue
res = isOK(new)
if res:
print("YES")
return
print("NO")
cal(n) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR VAR FOR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER NUMBER VAR BIN_OP VAR NUMBER NUMBER RETURN VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR BIN_OP BIN_OP VAR NUMBER VAR VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR EXPR FUNC_CALL VAR STRING RETURN ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR EXPR FUNC_CALL VAR STRING RETURN ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR EXPR FUNC_CALL VAR STRING RETURN EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR VAR |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | d = list(map(int, input().split()))
d = [0] + d
def ff(g):
if g[1] == g[2] == g[3] == g[0]:
return True
return False
def df(g):
return [g[1], g[3], g[0], g[2]]
if ff(d[13:17]) & ff(d[17:21]):
a = d[:]
b = True
for i in range(1, 25, 4):
if a[i] != a[i + 2]:
b = False
for i in range(2, 25, 4):
if a[i] != a[i + 2]:
b = False
if b == False:
print("NO")
elif (a[1] == a[6]) & (a[5] == a[10]) & (a[9] == a[21]) & (a[2] == a[22]) | (
a[5] == a[2]
) & (a[9] == a[6]) & (a[24] == a[12]) & (a[21] == a[1]):
print("YES")
else:
print("NO")
elif ff(d[1:5]) & ff(d[9:13]):
a = d[:]
a[1:5], a[13:17], a[9:13], a[17:21] = (
df(a[17:21]),
df(a[1:5]),
df(a[13:17]),
df(a[9:13]),
)
a[5:9] = df(a[5:9])
a[21:25] = df(df(df(a[21:25])))
b = True
for i in range(1, 25, 4):
if a[i] != a[i + 2]:
b = False
for i in range(2, 25, 4):
if a[i] != a[i + 2]:
b = False
if b == False:
print("NO")
elif (a[1] == a[6]) & (a[5] == a[10]) & (a[9] == a[21]) & (a[2] == a[22]) | (
a[5] == a[2]
) & (a[9] == a[6]) & (a[24] == a[12]) & (a[21] == a[1]):
print("YES")
else:
print("NO")
elif ff(d[5:9]) & ff(d[21:25]):
a = d[:]
a[1:5], a[9:13] = df(df(df(a[1:5]))), df(a[9:13])
a[13:17], a[5:9], a[17:21], a[21:25] = a[5:9], a[17:21], a[21:25], a[13:17]
b = True
for i in range(1, 25, 4):
if a[i] != a[i + 2]:
b = False
for i in range(2, 25, 4):
if a[i] != a[i + 2]:
b = False
if b == False:
print("NO")
elif (a[1] == a[6]) & (a[5] == a[10]) & (a[9] == a[21]) & (a[2] == a[22]) | (
a[5] == a[2]
) & (a[9] == a[6]) & (a[24] == a[12]) & (a[21] == a[1]):
print("YES")
else:
print("NO")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FUNC_DEF IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF RETURN LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING IF BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING IF BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING IF BIN_OP BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | l = list(map(int, input().split()))
l.insert(0, 0)
l1 = [13, 14, 15, 16]
l2 = [17, 18, 19, 20]
l3 = [1, 3, 6, 8]
l4 = [2, 4, 22, 24]
l5 = [5, 7, 10, 12]
l6 = [9, 11, 21, 23]
check = 0
if l[l1[0]] == l[l1[1]] == l[l1[2]] == l[l1[3]]:
if l[l2[0]] == l[l2[1]] == l[l2[2]] == l[l2[3]]:
if l[l3[0]] == l[l3[1]] == l[l3[2]] == l[l3[3]]:
if l[l4[0]] == l[l4[1]] == l[l4[2]] == l[l4[3]]:
if l[l5[0]] == l[l5[1]] == l[l5[2]] == l[l5[3]]:
if l[l6[0]] == l[l6[1]] == l[l6[2]] == l[l6[3]]:
check = 1
if check:
print("YES"), exit(0)
l1 = [13, 14, 15, 16]
l2 = [17, 18, 19, 20]
l3 = [1, 3, 21, 23]
l4 = [5, 7, 2, 4]
l5 = [9, 11, 6, 8]
l6 = [10, 12, 22, 24]
check = 0
if l[l1[0]] == l[l1[1]] == l[l1[2]] == l[l1[3]]:
if l[l2[0]] == l[l2[1]] == l[l2[2]] == l[l2[3]]:
if l[l3[0]] == l[l3[1]] == l[l3[2]] == l[l3[3]]:
if l[l4[0]] == l[l4[1]] == l[l4[2]] == l[l4[3]]:
if l[l5[0]] == l[l5[1]] == l[l5[2]] == l[l5[3]]:
if l[l6[0]] == l[l6[1]] == l[l6[2]] == l[l6[3]]:
check = 1
if check:
print("YES"), exit(0)
l1 = [1, 2, 3, 4]
l2 = [9, 10, 11, 12]
l3 = [5, 6, 19, 20]
l4 = [7, 8, 13, 14]
l5 = [15, 16, 21, 22]
l6 = [17, 18, 23, 24]
if l[l1[0]] == l[l1[1]] == l[l1[2]] == l[l1[3]]:
if l[l2[0]] == l[l2[1]] == l[l2[2]] == l[l2[3]]:
if l[l3[0]] == l[l3[1]] == l[l3[2]] == l[l3[3]]:
if l[l4[0]] == l[l4[1]] == l[l4[2]] == l[l4[3]]:
if l[l5[0]] == l[l5[1]] == l[l5[2]] == l[l5[3]]:
if l[l6[0]] == l[l6[1]] == l[l6[2]] == l[l6[3]]:
check = 1
if check:
print("YES"), exit(0)
l1 = [1, 2, 3, 4]
l2 = [9, 10, 11, 12]
l3 = [5, 6, 15, 16]
l4 = [23, 24, 13, 14]
l5 = [19, 20, 21, 22]
l6 = [7, 8, 17, 18]
if l[l1[0]] == l[l1[1]] == l[l1[2]] == l[l1[3]]:
if l[l2[0]] == l[l2[1]] == l[l2[2]] == l[l2[3]]:
if l[l3[0]] == l[l3[1]] == l[l3[2]] == l[l3[3]]:
if l[l4[0]] == l[l4[1]] == l[l4[2]] == l[l4[3]]:
if l[l5[0]] == l[l5[1]] == l[l5[2]] == l[l5[3]]:
if l[l6[0]] == l[l6[1]] == l[l6[2]] == l[l6[3]]:
check = 1
if check:
print("YES"), exit(0)
l1 = [5, 6, 7, 8]
l2 = [21, 22, 23, 24]
l3 = [1, 2, 17, 19]
l4 = [3, 4, 13, 15]
l5 = [9, 10, 18, 20]
l6 = [11, 12, 14, 16]
if l[l1[0]] == l[l1[1]] == l[l1[2]] == l[l1[3]]:
if l[l2[0]] == l[l2[1]] == l[l2[2]] == l[l2[3]]:
if l[l3[0]] == l[l3[1]] == l[l3[2]] == l[l3[3]]:
if l[l4[0]] == l[l4[1]] == l[l4[2]] == l[l4[3]]:
if l[l5[0]] == l[l5[1]] == l[l5[2]] == l[l5[3]]:
if l[l6[0]] == l[l6[1]] == l[l6[2]] == l[l6[3]]:
check = 1
if check:
print("YES"), exit(0)
l1 = [5, 6, 7, 8]
l2 = [21, 22, 23, 24]
l3 = [3, 4, 18, 20]
l4 = [17, 19, 11, 12]
l5 = [9, 10, 15, 13]
l6 = [14, 16, 1, 2]
if l[l1[0]] == l[l1[1]] == l[l1[2]] == l[l1[3]]:
if l[l2[0]] == l[l2[1]] == l[l2[2]] == l[l2[3]]:
if l[l3[0]] == l[l3[1]] == l[l3[2]] == l[l3[3]]:
if l[l4[0]] == l[l4[1]] == l[l4[2]] == l[l4[3]]:
if l[l5[0]] == l[l5[1]] == l[l5[2]] == l[l5[3]]:
if l[l6[0]] == l[l6[1]] == l[l6[2]] == l[l6[3]]:
check = 1
if check:
print("YES"), exit(0)
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING FUNC_CALL VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING FUNC_CALL VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING FUNC_CALL VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING FUNC_CALL VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING FUNC_CALL VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER IF VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def R(b):
c = []
for i in b:
c.append(i)
c[1] = b[5]
c[3] = b[7]
c[5] = b[9]
c[7] = b[11]
c[9] = b[22]
c[11] = b[20]
c[22] = b[1]
c[20] = b[3]
d = []
for i in range(23):
if c[i] != c[i + 1]:
d.append(c[i])
d.append(c[-1])
if len(d) == 6:
return True
else:
return False
def Rp(b):
c = []
for i in b:
c.append(i)
c[5] = b[1]
c[7] = b[3]
c[9] = b[5]
c[11] = b[7]
c[22] = b[9]
c[20] = b[11]
c[1] = b[22]
c[3] = b[20]
d = []
for i in range(23):
if c[i] != c[i + 1]:
d.append(c[i])
d.append(c[-1])
if len(d) == 6:
return True
else:
return False
def U(b):
c = []
for i in b:
c.append(i)
c[4] = b[16]
c[5] = b[17]
c[16] = b[20]
c[17] = b[21]
c[20] = b[12]
c[21] = b[13]
c[12] = b[4]
c[13] = b[5]
d = []
for i in range(23):
if c[i] != c[i + 1]:
d.append(c[i])
d.append(c[-1])
if len(d) == 6:
return True
else:
return False
def Up(b):
c = []
for i in b:
c.append(i)
c[16] = b[4]
c[17] = b[5]
c[20] = b[16]
c[21] = b[17]
c[12] = b[20]
c[13] = b[21]
c[4] = b[12]
c[5] = b[13]
d = []
for i in range(23):
if c[i] != c[i + 1]:
d.append(c[i])
d.append(c[-1])
if len(d) == 6:
return True
else:
return False
def F(b):
c = []
for i in b:
c.append(i)
c[13] = b[3]
c[15] = b[2]
c[8] = b[13]
c[9] = b[15]
c[18] = b[8]
c[16] = b[9]
c[3] = b[18]
c[2] = b[16]
d = []
for i in range(23):
if c[i] != c[i + 1]:
d.append(c[i])
d.append(c[-1])
if len(d) == 6:
return True
else:
return False
def Fp(b):
c = []
for i in b:
c.append(i)
c[3] = b[13]
c[2] = b[15]
c[13] = b[8]
c[15] = b[9]
c[8] = b[18]
c[9] = b[16]
c[18] = b[3]
c[16] = b[2]
d = []
for i in range(23):
if c[i] != c[i + 1]:
d.append(c[i])
d.append(c[-1])
if len(d) == 6:
return True
else:
return False
a = list(map(int, input().split()))
if R(a) or Rp(a) or Up(a) or U(a) or F(a) or Fp(a):
print("yes")
else:
print("no") | FUNC_DEF ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def checkRubik(l):
for i in range(1, 25, 4):
for j in range(i + 1, i + 4):
if l[j] != l[i]:
return False
return True
a = list(map(int, input().split()))
a.insert(0, 0)
o = checkRubik(a)
if not o:
b = a
b[1], b[3], b[5], b[7], b[9], b[11], b[24], b[22] = (
b[24],
b[22],
b[1],
b[3],
b[5],
b[7],
b[9],
b[11],
)
o = checkRubik(b)
if not o:
b = a
b[1], b[3], b[5], b[7], b[9], b[11], b[24], b[22] = (
b[5],
b[7],
b[9],
b[11],
b[24],
b[22],
b[1],
b[3],
)
o = checkRubik(b)
if not o:
b = a
b[2], b[4], b[6], b[8], b[10], b[12], b[23], b[21] = (
b[23],
b[21],
b[2],
b[4],
b[6],
b[8],
b[10],
b[12],
)
o = checkRubik(b)
if not o:
b = a
b[2], b[4], b[6], b[8], b[10], b[12], b[23], b[21] = (
b[6],
b[8],
b[10],
b[12],
b[23],
b[21],
b[2],
b[4],
)
o = checkRubik(b)
if not o:
b = a
b[13], b[14], b[5], b[6], b[17], b[18], b[21], b[22] = (
b[21],
b[22],
b[13],
b[14],
b[5],
b[6],
b[17],
b[18],
)
o = checkRubik(b)
if not o:
b = a
b[13], b[14], b[5], b[6], b[17], b[18], b[21], b[22] = (
b[5],
b[6],
b[17],
b[18],
b[21],
b[22],
b[13],
b[14],
)
o = checkRubik(b)
if not o:
b = a
b[15], b[16], b[7], b[8], b[19], b[20], b[23], b[24] = (
b[23],
b[24],
b[15],
b[16],
b[7],
b[8],
b[19],
b[20],
)
o = checkRubik(b)
if not o:
b = a
b[15], b[16], b[7], b[8], b[19], b[20], b[23], b[24] = (
b[7],
b[8],
b[19],
b[20],
b[23],
b[24],
b[15],
b[16],
)
o = checkRubik(b)
if not o:
b = a
b[3], b[4], b[17], b[19], b[10], b[9], b[16], b[14] = (
b[16],
b[14],
b[3],
b[4],
b[17],
b[19],
b[10],
b[9],
)
o = checkRubik(b)
if not o:
b = a
b[3], b[4], b[17], b[19], b[10], b[9], b[16], b[14] = (
b[17],
b[19],
b[10],
b[9],
b[16],
b[14],
b[3],
b[4],
)
o = checkRubik(b)
if not o:
b = a
b[1], b[2], b[18], b[20], b[12], b[11], b[15], b[13] = (
b[15],
b[13],
b[1],
b[2],
b[18],
b[20],
b[12],
b[11],
)
o = checkRubik(b)
if not o:
b = a
b[1], b[2], b[18], b[20], b[12], b[11], b[15], b[13] = (
b[18],
b[20],
b[12],
b[11],
b[15],
b[13],
b[1],
b[2],
)
o = checkRubik(b)
if not o:
print("NO")
else:
print("YES")
else:
print("NO") | FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | r = [
"111155223333224466554466",
"111144223333664422555566",
"114422225533434315156666",
"115522224433414135356666",
"111122553333442255666644",
"111122443333446655226655",
"212132326363444455556161",
"616112122323444455556363",
"121223233636444455551616",
"161621213232444455553636",
"551122223344141453536666",
"441122223355343451516666",
]
a = "".join(input().split(" "))
for b in r:
ok = True
for i in range(24):
for j in range(24):
if b[i] == b[j] and a[i] != a[j] or b[i] != b[j] and a[i] == a[j]:
ok = False
if ok:
break
if ok:
print("YES")
else:
print("NO") | ASSIGN VAR LIST STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING STRING ASSIGN VAR FUNC_CALL STRING FUNC_CALL FUNC_CALL VAR STRING FOR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR NUMBER IF VAR IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | indexes = [
[
[1, 2, 3, 4],
[9, 10, 11, 12],
[13, 14, 7, 8],
[5, 6, 19, 20],
[17, 18, 23, 24],
[21, 22, 15, 16],
],
[
[1, 2, 3, 4],
[9, 10, 11, 12],
[5, 6, 15, 16],
[17, 18, 7, 8],
[21, 22, 19, 20],
[13, 14, 23, 24],
],
[
[17, 18, 19, 20],
[13, 14, 15, 16],
[21, 23, 1, 3],
[10, 12, 22, 24],
[6, 8, 9, 11],
[2, 4, 5, 7],
],
[
[17, 18, 19, 20],
[13, 14, 15, 16],
[2, 4, 22, 24],
[9, 11, 21, 23],
[5, 7, 10, 12],
[1, 3, 6, 8],
],
[
[5, 6, 7, 8],
[21, 22, 23, 24],
[3, 4, 18, 20],
[17, 19, 11, 12],
[9, 10, 13, 15],
[1, 2, 14, 16],
],
[
[5, 6, 7, 8],
[21, 22, 23, 24],
[1, 2, 17, 19],
[9, 10, 18, 20],
[14, 16, 11, 12],
[3, 4, 13, 15],
],
]
def same_color(ls, cube):
first = cube[ls[0]]
for ind in ls:
if cube[ind] != first:
return False
return True
inp = input().split(" ")
inp = ["0"] + inp
work = False
for turn in indexes:
work = True
for grain in turn:
if not same_color(grain, inp):
work = False
if work:
print("YES")
exit(0)
print("NO") | ASSIGN VAR LIST LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR VAR VAR NUMBER FOR VAR VAR IF VAR VAR VAR RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR BIN_OP LIST STRING VAR ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR NUMBER FOR VAR VAR IF FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | cube_state = list(map(int, input().split()))
def is_solved(cube_state):
previous = None
for i in range(24):
if i % 4 == 0:
previous = cube_state[i]
elif cube_state[i] != previous:
return False
return True
def transfer(array, src, dest):
copied = array[:]
for index in range(len(src)):
copied[dest[index] - 1] = array[src[index] - 1]
return copied
def try_solution_and_inverse(cube_state, src, dest):
if is_solved(transfer(cube_state, src, dest)):
return True
if is_solved(transfer(cube_state, dest, src)):
return True
return False
def can_solve(cube_state):
if try_solution_and_inverse(
cube_state,
[1, 2, 3, 4, 5, 6, 17, 18, 21, 22, 13, 14],
[2, 4, 1, 3, 13, 14, 5, 6, 17, 18, 21, 22],
):
return True
if try_solution_and_inverse(
cube_state,
[11, 12, 10, 9, 7, 8, 19, 20, 23, 24, 15, 16],
[12, 10, 9, 11, 15, 16, 7, 8, 19, 20, 23, 24],
):
return True
for _ in range(4):
if try_solution_and_inverse(
cube_state,
[5, 6, 8, 7, 3, 4, 17, 19, 10, 9, 16, 14],
[6, 8, 7, 5, 17, 19, 10, 9, 16, 14, 3, 4],
):
return True
cube_state = transfer(
cube_state,
[
3,
1,
4,
2,
17,
18,
19,
20,
10,
12,
9,
11,
5,
6,
7,
8,
21,
22,
23,
24,
13,
14,
15,
16,
],
list(range(1, 24 + 1)),
)
return False
if can_solve(cube_state):
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR NONE FOR VAR FUNC_CALL VAR NUMBER IF BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR VAR IF VAR VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR VAR NUMBER RETURN VAR FUNC_DEF IF FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR RETURN NUMBER IF FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR RETURN NUMBER RETURN NUMBER FUNC_DEF IF FUNC_CALL VAR VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER RETURN NUMBER IF FUNC_CALL VAR VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER RETURN NUMBER FOR VAR FUNC_CALL VAR NUMBER IF FUNC_CALL VAR VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP NUMBER NUMBER RETURN NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def full(x):
if x.count(x[0]) == 4:
return True
else:
return False
def gor(x):
if x[0] == x[1] and x[2] == x[3] and x[0] != x[2]:
return True
else:
return False
def vert(x):
if x[0] == x[2] and x[1] == x[3] and x[0] != x[1]:
return True
else:
return False
l = list(map(int, input().split()))
a = l[:4]
b = l[4:8]
c = l[8:12]
d = l[12:16]
e = l[16:20]
f = l[20:24]
if (
full(a)
and full(c)
and gor(d)
and gor(b)
and gor(e)
and gor(f)
and (
d[0] == b[3]
and b[0] == e[3]
and e[0] == f[3]
and f[0] == d[3]
or d[0] == f[3]
and b[0] == d[3]
and e[0] == b[3]
and f[0] == e[3]
)
):
print("YES")
elif (
full(d)
and full(e)
and vert(a)
and vert(b)
and vert(c)
and vert(f)
and (
a[0] == b[3]
and b[0] == c[3]
and c[0] == f[0]
and f[3] == a[3]
or a[0] == f[0]
and b[0] == a[3]
and c[0] == b[3]
and f[3] == c[3]
)
):
print("YES")
elif (
full(b)
and full(f)
and vert(d)
and gor(a)
and vert(e)
and gor(c)
and (
d[0] == a[3]
and a[0] == e[0]
and e[3] == c[0]
and c[3] == d[3]
or d[0] == c[0]
and c[3] == e[0]
and e[3] == a[3]
and a[0] == d[3]
)
):
print("YES")
else:
print("NO") | FUNC_DEF IF FUNC_CALL VAR VAR NUMBER NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER ASSIGN VAR VAR NUMBER NUMBER IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def xd(a, b, c, d):
global s
if s[a - 1] == s[b - 1] and s[b - 1] == s[c - 1] and s[c - 1] == s[d - 1]:
return 1
else:
return 0
s = list(map(int, input().split()))
pd = 0
if (
xd(13, 14, 15, 16)
and xd(17, 18, 19, 20)
and xd(1, 3, 6, 8)
and xd(5, 7, 10, 12)
and xd(9, 11, 21, 23)
and xd(2, 4, 22, 24)
):
pd = 1
if (
xd(13, 14, 15, 16)
and xd(17, 18, 19, 20)
and xd(1, 3, 21, 23)
and xd(5, 7, 2, 4)
and xd(9, 11, 6, 8)
and xd(22, 24, 10, 12)
):
pd = 1
if (
xd(1, 2, 3, 4)
and xd(9, 10, 11, 12)
and xd(5, 6, 19, 20)
and xd(17, 18, 23, 24)
and xd(21, 22, 15, 16)
and xd(13, 14, 7, 8)
):
pd = 1
if (
xd(1, 2, 3, 4)
and xd(9, 10, 11, 12)
and xd(5, 6, 15, 16)
and xd(17, 18, 7, 8)
and xd(21, 22, 19, 20)
and xd(13, 14, 23, 24)
):
pd = 1
if (
xd(5, 6, 7, 8)
and xd(21, 22, 23, 24)
and xd(3, 4, 13, 15)
and xd(14, 16, 11, 12)
and xd(9, 10, 18, 20)
and xd(17, 19, 1, 2)
):
pd = 1
if (
xd(5, 6, 7, 8)
and xd(21, 22, 23, 24)
and xd(3, 4, 18, 20)
and xd(14, 16, 1, 2)
and xd(9, 10, 13, 15)
and xd(17, 19, 11, 12)
):
pd = 1
if pd == 1:
print("YES")
else:
print("NO") | FUNC_DEF IF VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER IF FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER ASSIGN VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def check(dat):
mark = 0
for i in range(6):
if (
dat[4 * i] == dat[4 * i + 1]
and dat[4 * i] == dat[4 * i + 2]
and dat[4 * i] == dat[4 * i + 3]
):
mark += 1
if mark == 6:
return True
return False
data = list(map(int, input().split()))
for i in range(1):
data2 = data.copy()
data2[0] = data[14]
data2[1] = data[12]
data2[14] = data[11]
data2[12] = data[10]
data2[11] = data[17]
data2[10] = data[19]
data2[17] = data[0]
data2[19] = data[1]
if check(data2):
print("YES")
exit(0)
data2 = data.copy()
data2[0] = data[17]
data2[1] = data[19]
data2[17] = data[11]
data2[19] = data[10]
data2[11] = data[14]
data2[10] = data[12]
data2[14] = data[0]
data2[12] = data[1]
if check(data2):
print("YES")
exit(0)
data2 = data.copy()
data2[0] = data[4]
data2[2] = data[6]
data2[4] = data[8]
data2[6] = data[10]
data2[8] = data[23]
data2[10] = data[21]
data2[23] = data[0]
data2[21] = data[2]
if check(data2):
print("YES")
exit(0)
data2 = data.copy()
data2[0] = data[23]
data2[2] = data[21]
data2[23] = data[8]
data2[21] = data[10]
data2[8] = data[4]
data2[10] = data[6]
data2[4] = data[0]
data2[6] = data[2]
if check(data2):
print("YES")
exit(0)
data2 = data.copy()
data2[4] = data[16]
data2[5] = data[17]
data2[16] = data[20]
data2[17] = data[21]
data2[20] = data[12]
data2[21] = data[13]
data2[12] = data[4]
data2[13] = data[5]
if check(data2):
print("YES")
exit(0)
data2 = data.copy()
data2[4] = data[12]
data2[5] = data[13]
data2[12] = data[20]
data2[13] = data[21]
data2[20] = data[16]
data2[21] = data[17]
data2[16] = data[4]
data2[17] = data[5]
if check(data2):
print("YES")
exit(0)
print("NO") | FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | import sys
rotations = [
[1, 3, 5, 7, 9, 11, 22, 24],
[2, 4, 6, 8, 10, 12, 21, 23],
[13, 14, 5, 6, 17, 18, 21, 22],
[15, 16, 7, 8, 19, 20, 23, 24],
[3, 4, 17, 19, 10, 9, 16, 14],
[1, 2, 18, 20, 12, 11, 15, 13],
]
def rotation_backwards(cube: list, rotation: list):
aux = cube.copy()
aux_1 = aux[rotation[len(rotation) - 1] - 1]
aux_2 = aux[rotation[len(rotation) - 1] - 1]
for index in range(len(rotation) - 1, -1, -1):
aux[rotation[index] - 1] = aux[rotation[(index - 2) % len(rotation)] - 1]
aux[rotation[0] - 1] = aux_1
aux[rotation[1] - 1] = aux_2
return aux
def rotation_forwards(cube: list, rotation: list):
aux = cube.copy()
aux_1 = aux[rotation[0] - 1]
aux_2 = aux[rotation[1] - 1]
for index in range(len(rotation)):
aux[rotation[index] - 1] = aux[rotation[(index + 2) % len(rotation)] - 1]
aux[rotation[len(rotation) - 1] - 1] = aux_1
aux[rotation[len(rotation) - 1] - 1] = aux_2
return aux
def verify(cube: list):
equals = 0
for i in range(0, len(cube), 4):
if cube[i] == cube[i + 1] and cube[i] == cube[i + 2] and cube[i] == cube[i + 3]:
equals += 1
else:
break
if equals == 6:
print("YES")
sys.exit(0)
cube = list(map(int, input().split(" ")))
for r in rotations:
verify(rotation_backwards(cube, r))
verify(rotation_forwards(cube, r))
print("NO") | IMPORT ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER NUMBER VAR RETURN VAR FUNC_DEF VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR BIN_OP VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR NUMBER ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER VAR ASSIGN VAR BIN_OP VAR BIN_OP FUNC_CALL VAR VAR NUMBER NUMBER VAR RETURN VAR FUNC_DEF VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR VAR VAR BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING FOR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | line = input().split()
a = []
for i in line:
a.append(int(i))
def isValid(b):
flag = 0
if (
b[flag] != b[flag + 1]
or b[flag + 1] != b[flag + 2]
or b[flag + 2] != b[flag + 3]
):
return False
flag = 4
if (
b[flag] != b[flag + 1]
or b[flag + 1] != b[flag + 2]
or b[flag + 2] != b[flag + 3]
):
return False
flag = 8
if (
b[flag] != b[flag + 1]
or b[flag + 1] != b[flag + 2]
or b[flag + 2] != b[flag + 3]
):
return False
flag = 12
if (
b[flag] != b[flag + 1]
or b[flag + 1] != b[flag + 2]
or b[flag + 2] != b[flag + 3]
):
return False
flag = 16
if (
b[flag] != b[flag + 1]
or b[flag + 1] != b[flag + 2]
or b[flag + 2] != b[flag + 3]
):
return False
flag = 20
if (
b[flag] != b[flag + 1]
or b[flag + 1] != b[flag + 2]
or b[flag + 2] != b[flag + 3]
):
return False
return True
def rotate():
q = []
for i in a:
q.append(i)
q[4], q[6], q[8], q[10], q[21], q[23], q[0], q[2] = (
q[0],
q[2],
q[4],
q[6],
q[8],
q[10],
q[21],
q[23],
)
if isValid(q):
return True
q.clear()
for i in a:
q.append(i)
q[0], q[2], q[4], q[6], q[8], q[10], q[21], q[23] = (
q[4],
q[6],
q[8],
q[10],
q[21],
q[23],
q[0],
q[2],
)
if isValid(q):
return True
q.clear()
for i in a:
q.append(i)
q[12], q[13], q[4], q[5], q[16], q[17], q[20], q[21] = (
q[20],
q[21],
q[12],
q[13],
q[4],
q[5],
q[16],
q[17],
)
if isValid(q):
return True
q.clear()
for i in a:
q.append(i)
q[20], q[21], q[12], q[13], q[4], q[5], q[16], q[17] = (
q[12],
q[13],
q[4],
q[5],
q[16],
q[17],
q[20],
q[21],
)
if isValid(q):
return True
q.clear()
for i in a:
q.append(i)
q[15], q[13], q[2], q[3], q[16], q[18], q[9], q[8] = (
q[2],
q[3],
q[16],
q[18],
q[9],
q[8],
q[15],
q[13],
)
if isValid(q):
return True
q.clear()
for i in a:
q.append(i)
q[2], q[3], q[16], q[18], q[9], q[8], q[15], q[13] = (
q[15],
q[13],
q[2],
q[3],
q[16],
q[18],
q[9],
q[8],
)
if isValid(q):
return True
return False
if rotate():
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_DEF ASSIGN VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR RETURN NUMBER EXPR FUNC_CALL VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR RETURN NUMBER EXPR FUNC_CALL VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR RETURN NUMBER EXPR FUNC_CALL VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR RETURN NUMBER EXPR FUNC_CALL VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR RETURN NUMBER EXPR FUNC_CALL VAR FOR VAR VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR RETURN NUMBER RETURN NUMBER IF FUNC_CALL VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def f(a, b, c, d):
return a == b == c == d
a = [0]
a.extend(list(map(int, input().split())))
if f(a[13], a[14], a[15], a[16]) and f(a[17], a[18], a[19], a[20]):
if f(a[6], a[8], a[1], a[3]) and f(a[2], a[4], a[22], a[24]):
if f(a[21], a[23], a[9], a[11]) and f(a[10], a[12], a[5], a[7]):
print("YES")
exit()
if f(a[6], a[8], a[9], a[11]) and f(a[10], a[12], a[22], a[24]):
if f(a[21], a[23], a[1], a[3]) and f(a[2], a[4], a[5], a[7]):
print("YES")
exit()
if f(a[5], a[6], a[7], a[8]) and f(a[21], a[22], a[23], a[24]):
if f(a[17], a[19], a[1], a[2]) and f(a[3], a[4], a[13], a[15]):
if f(a[14], a[16], a[11], a[12]) and f(a[9], a[10], a[18], a[20]):
print("YES")
exit()
if f(a[18], a[20], a[3], a[4]) and f(a[1], a[2], a[14], a[16]):
if f(a[13], a[15], a[9], a[10]) and f(a[11], a[12], a[17], a[19]):
print("YES")
exit()
if f(a[9], a[10], a[11], a[12]) and f(a[1], a[2], a[3], a[4]):
if f(a[13], a[14], a[7], a[8]) and f(a[5], a[6], a[19], a[20]):
if f(a[17], a[18], a[23], a[24]) and f(a[21], a[22], a[15], a[16]):
print("YES")
exit()
if f(a[15], a[16], a[5], a[6]) and f(a[7], a[8], a[17], a[18]):
if f(a[19], a[20], a[21], a[22]) and f(a[23], a[24], a[13], a[14]):
print("YES")
exit()
print("NO") | FUNC_DEF RETURN VAR VAR VAR VAR ASSIGN VAR LIST NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def final(b):
for i in range(6):
if len(set(b[4 * i : 4 * i + 4])) != 1:
return False
return True
a = list(map(int, input().split()))
moves = [
[4, 5, 16, 17, 20, 21, 12, 13],
[13, 15, 8, 9, 18, 16, 3, 2],
[15, 14, 23, 22, 19, 18, 7, 6],
[21, 23, 10, 8, 6, 4, 2, 0],
[5, 7, 9, 11, 22, 20, 1, 3],
[17, 19, 11, 10, 14, 12, 0, 1],
]
for index, m in enumerate(moves):
permutation = [i for i in range(24)]
inverse = [i for i in range(24)]
for j in range(8):
first = m[j]
second = m[(j + 2) % 8]
permutation[first] = second
inverse[second] = first
b = [a[permutation[i]] for i in range(24)]
c = [a[inverse[i]] for i in range(24)]
if final(b) or final(c):
print("YES")
exit()
print("NO") | FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER IF FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR VAR VAR FUNC_CALL VAR NUMBER IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | arr = list(map(int, input().split()))
def cycle(p, q, r, s, b):
if b:
arr[p], arr[q], arr[r], arr[s] = arr[q], arr[r], arr[s], arr[p]
else:
arr[s], arr[r], arr[q], arr[p] = arr[r], arr[q], arr[p], arr[s]
def solved():
for i in range(6):
for j in range(1, 4):
if arr[4 * i + j] != arr[4 * i]:
return False
return True
def rotate(k, b):
cycle(4 * k, 4 * k + 1, 4 * k + 3, 4 * k + 2, b)
if k == 0:
cycle(21, 17, 5, 13, b)
cycle(12, 20, 16, 4, b)
elif k == 1:
cycle(2, 16, 9, 15, b)
cycle(3, 18, 8, 13, b)
elif k == 2:
cycle(6, 18, 22, 14, b)
cycle(7, 19, 23, 15, b)
elif k == 3:
cycle(0, 4, 8, 23, b)
cycle(2, 6, 10, 21, b)
elif k == 4:
cycle(3, 20, 11, 7, b)
cycle(1, 22, 9, 5, b)
elif k == 5:
cycle(1, 12, 10, 19, b)
cycle(0, 14, 11, 17, b)
for i in range(6):
for j in range(2):
rotate(i, j)
if solved():
print("YES")
exit()
rotate(i, 1 - j)
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF IF VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR VAR VAR BIN_OP NUMBER VAR RETURN NUMBER RETURN NUMBER FUNC_DEF EXPR FUNC_CALL VAR BIN_OP NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER BIN_OP BIN_OP NUMBER VAR NUMBER BIN_OP BIN_OP NUMBER VAR NUMBER VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR IF VAR NUMBER EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR EXPR FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR VAR BIN_OP NUMBER VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | import sys
try:
sys.stdin = open("input.txt", "r")
sys.stdout = open("output.txt", "w")
except:
pass
input = sys.stdin.readline
def solved(a):
side1 = set(a[:4])
side2 = set(a[4:8])
side3 = set(a[8:12])
side4 = set(a[12:16])
side5 = set(a[16:20])
side6 = set(a[20:24])
for side in [side1, side2, side3, side4, side5, side6]:
if len(side) != 1:
return False
return True
a = list(map(int, input().split()))
turn1 = {(1): 5, (3): 7, (5): 9, (7): 11, (9): 24, (11): 22, (24): 1, (22): 3}
turn2 = {(2): 6, (4): 8, (6): 10, (8): 12, (10): 21, (12): 23, (23): 2, (21): 4}
turn3 = {(5): 13, (6): 14, (17): 5, (18): 6, (21): 17, (22): 18, (13): 21, (14): 22}
turn4 = {(7): 15, (8): 16, (19): 7, (20): 8, (23): 19, (24): 20, (16): 24, (15): 23}
turn5 = {(17): 10, (19): 9, (9): 14, (10): 16, (14): 4, (16): 3, (4): 19, (3): 17}
turn6 = {(18): 12, (20): 11, (11): 13, (12): 15, (13): 2, (15): 1, (2): 20, (1): 18}
for turn in [turn1, turn2, turn3, turn4, turn5, turn6]:
new_a = [ai for ai in a]
for old, new in turn.items():
new_a[old - 1] = a[new - 1]
if solved(new_a):
print("YES")
break
else:
print("NO") | IMPORT ASSIGN VAR FUNC_CALL VAR STRING STRING ASSIGN VAR FUNC_CALL VAR STRING STRING ASSIGN VAR VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR VAR NUMBER NUMBER FOR VAR LIST VAR VAR VAR VAR VAR VAR IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR LIST VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR FOR VAR VAR FUNC_CALL VAR ASSIGN VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = [
[1, 3, 5, 7, 9, 11, 24, 22],
[2, 4, 6, 8, 10, 12, 23, 21],
[13, 14, 5, 6, 17, 18, 21, 22],
[15, 16, 7, 8, 19, 20, 23, 24],
[16, 14, 3, 4, 17, 19, 10, 9],
[15, 13, 1, 2, 18, 20, 12, 11],
]
def rotate(b, i1, i2, i3, i4, i5, i6, i7, i8):
b[i1], b[i2], b[i3], b[i4], b[i5], b[i6], b[i7], b[i8] = (
b[i7],
b[i8],
b[i1],
b[i2],
b[i3],
b[i4],
b[i5],
b[i6],
)
y = 1
for k in range(1, 24, 4):
y &= all(map(lambda x: x == b[k], b[k : k + 4]))
return y
b = list(map(int, input().split()))
b.insert(0, 0)
y = 0
for i in a:
y |= rotate(list(b), *i)
y |= rotate(list(b), *reversed(i))
print("YES" if y else "NO") | ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR VAR BIN_OP VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR STRING STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def f(i):
nonlocal cube
return cube[i - 1]
cube = input().split()
if f(1) == f(2) and f(1) == f(3) and f(1) == f(4):
if f(9) == f(10) and f(9) == f(11) and f(9) == f(12):
if f(5) == f(6) and f(5) == f(15) and f(5) == f(16):
if f(13) == f(14) and f(13) == f(23) and f(13) == f(24):
if f(7) == f(8) and f(7) == f(17) and f(7) == f(18):
if f(21) == f(22) and f(21) == f(19) and f(21) == f(20):
print("YES")
return
if f(13) == f(14) and f(13) == f(7) and f(13) == f(8):
if f(5) == f(6) and f(5) == f(19) and f(5) == f(20):
if f(17) == f(18) and f(17) == f(23) and f(17) == f(24):
if f(21) == f(22) and f(21) == f(15) and f(21) == f(16):
print("YES")
return
if f(17) == f(18) and f(17) == f(19) and f(17) == f(20):
if f(13) == f(14) and f(13) == f(15) and f(13) == f(16):
if f(24) == f(22) and f(24) == f(10) and f(24) == f(12):
if f(1) == f(3) and f(1) == f(23) and f(1) == f(21):
if f(5) == f(7) and f(5) == f(2) and f(5) == f(4):
if f(9) == f(11) and f(9) == f(6) and f(9) == f(8):
print("YES")
return
if f(24) == f(22) and f(24) == f(2) and f(24) == f(4):
if f(1) == f(3) and f(1) == f(6) and f(1) == f(8):
if f(5) == f(7) and f(5) == f(10) and f(5) == f(12):
if f(9) == f(11) and f(9) == f(23) and f(9) == f(21):
print("YES")
return
if f(5) == f(6) and f(5) == f(7) and f(5) == f(8):
if f(21) == f(22) and f(21) == f(23) and f(21) == f(24):
if f(3) == f(4) and f(17) == f(19) and f(10) == f(9) and f(16) == f(14):
if f(1) == f(2) and f(18) == f(20) and f(12) == f(11) and f(15) == f(13):
if (
f(3) == f(18)
and f(17) == f(12)
and f(10) == f(15)
and f(16) == f(1)
):
print("YES")
return
if (
f(3) == f(15)
and f(17) == f(1)
and f(10) == f(18)
and f(16) == f(12)
):
print("YES")
return
print("NO") | FUNC_DEF RETURN VAR BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING RETURN IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING RETURN IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING RETURN IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING RETURN IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING RETURN IF FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING RETURN EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = list(map(int, input().split()))
trans = [
{(1): 5, (3): 7, (5): 9, (7): 11, (9): 22, (11): 24, (22): 1, (24): 3},
{(5): 17, (6): 18, (17): 21, (18): 22, (21): 13, (22): 14, (13): 5, (14): 6},
{(3): 17, (4): 19, (17): 10, (19): 9, (9): 14, (10): 16, (14): 4, (16): 3},
]
def check(c):
for i in range(6):
if len(set(c[i * 4 + j] for j in range(4))) != 1:
return False
return True
def rotate(b, s, t):
c = b[:]
for i, j in zip(s, t):
c[i - 1] = b[j - 1]
return c
for k in trans:
if check(rotate(a, *zip(*k.items()))):
print("YES")
exit()
if check(rotate(a, *list(zip(*k.items()))[::-1])):
print("YES")
exit()
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER IF FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP BIN_OP VAR NUMBER VAR VAR FUNC_CALL VAR NUMBER NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR VAR FOR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER RETURN VAR FOR VAR VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | colors = list(map(int, input().split()))
can = False
if colors[16] == colors[17] == colors[22] == colors[23]:
if colors[4] == colors[5] == colors[18] == colors[19]:
if colors[12] == colors[13] == colors[6] == colors[7]:
if colors[20] == colors[21] == colors[14] == colors[15]:
if colors[0] == colors[1] == colors[2] == colors[3]:
if colors[8] == colors[9] == colors[10] == colors[11]:
can = True
if colors[12] == colors[13] == colors[22] == colors[23]:
if colors[20] == colors[21] == colors[18] == colors[19]:
if colors[16] == colors[17] == colors[6] == colors[7]:
if colors[4] == colors[5] == colors[14] == colors[15]:
if colors[0] == colors[1] == colors[2] == colors[3]:
if colors[8] == colors[9] == colors[10] == colors[11]:
can = True
if colors[14] == colors[12] == colors[2] == colors[3]:
if colors[0] == colors[1] == colors[16] == colors[18]:
if colors[17] == colors[19] == colors[8] == colors[9]:
if colors[10] == colors[11] == colors[13] == colors[15]:
if colors[20] == colors[21] == colors[22] == colors[23]:
if colors[4] == colors[5] == colors[6] == colors[7]:
can = True
if colors[17] == colors[19] == colors[2] == colors[3]:
if colors[10] == colors[11] == colors[16] == colors[18]:
if colors[0] == colors[1] == colors[13] == colors[15]:
if colors[14] == colors[12] == colors[8] == colors[9]:
if colors[20] == colors[21] == colors[22] == colors[23]:
if colors[4] == colors[5] == colors[6] == colors[7]:
can = True
if colors[1] == colors[3] == colors[21] == colors[23]:
if colors[5] == colors[7] == colors[0] == colors[2]:
if colors[9] == colors[11] == colors[4] == colors[6]:
if colors[20] == colors[22] == colors[8] == colors[10]:
if colors[16] == colors[17] == colors[18] == colors[19]:
if colors[12] == colors[13] == colors[14] == colors[15]:
can = True
if colors[9] == colors[11] == colors[21] == colors[23]:
if colors[20] == colors[22] == colors[0] == colors[2]:
if colors[5] == colors[7] == colors[8] == colors[10]:
if colors[1] == colors[3] == colors[4] == colors[6]:
if colors[16] == colors[17] == colors[18] == colors[19]:
if colors[12] == colors[13] == colors[14] == colors[15]:
can = True
if can:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | cube = [-1] + list(map(int, input().split()))
def ok(cube):
counter = 0
last = cube[1]
for i in cube:
if i == -1:
continue
elif last == i:
counter += 1
elif counter != 4:
return False
else:
counter = 1
last = i
return True
def rotl(cube):
cube_n = cube[:]
cube_n[1] = cube[3]
cube_n[2] = cube[1]
cube_n[3] = cube[4]
cube_n[4] = cube[2]
cube_n[5] = cube[17]
cube_n[6] = cube[18]
cube_n[17] = cube[21]
cube_n[18] = cube[22]
cube_n[21] = cube[13]
cube_n[22] = cube[14]
cube_n[13] = cube[5]
cube_n[14] = cube[6]
return cube_n
def rotr(cube):
cube_n = cube[:]
cube_n[1] = cube[2]
cube_n[2] = cube[4]
cube_n[3] = cube[1]
cube_n[4] = cube[3]
cube_n[5] = cube[13]
cube_n[6] = cube[14]
cube_n[17] = cube[5]
cube_n[18] = cube[6]
cube_n[21] = cube[17]
cube_n[22] = cube[18]
cube_n[13] = cube[21]
cube_n[14] = cube[22]
return cube_n
def next(cube):
cube_n = cube[:]
cube_n[1] = cube[5]
cube_n[2] = cube[6]
cube_n[3] = cube[7]
cube_n[4] = cube[8]
cube_n[5] = cube[9]
cube_n[6] = cube[10]
cube_n[7] = cube[11]
cube_n[8] = cube[12]
cube_n[9] = cube[24]
cube_n[10] = cube[23]
cube_n[11] = cube[22]
cube_n[12] = cube[21]
cube_n[13] = cube[14]
cube_n[14] = cube[16]
cube_n[15] = cube[13]
cube_n[16] = cube[15]
cube_n[17] = cube[19]
cube_n[18] = cube[17]
cube_n[19] = cube[20]
cube_n[20] = cube[18]
cube_n[21] = cube[4]
cube_n[22] = cube[3]
cube_n[23] = cube[2]
cube_n[24] = cube[1]
return cube_n
def next2(cube):
cube_n = cube[:]
cube_n[1] = cube[3]
cube_n[2] = cube[1]
cube_n[3] = cube[4]
cube_n[4] = cube[2]
cube_n[5] = cube[17]
cube_n[6] = cube[18]
cube_n[7] = cube[19]
cube_n[8] = cube[20]
cube_n[9] = cube[10]
cube_n[10] = cube[12]
cube_n[11] = cube[9]
cube_n[12] = cube[11]
cube_n[13] = cube[5]
cube_n[14] = cube[6]
cube_n[15] = cube[7]
cube_n[16] = cube[8]
cube_n[17] = cube[21]
cube_n[18] = cube[22]
cube_n[19] = cube[23]
cube_n[20] = cube[24]
cube_n[21] = cube[13]
cube_n[22] = cube[14]
cube_n[23] = cube[15]
cube_n[24] = cube[16]
return cube_n
def main(cube):
return ok(rotl(cube)) or ok(rotr(cube))
for i in range(4):
cube = next(cube)
if main(next(cube)):
print("YES")
return
for i in range(4):
cube = next2(cube)
if main(next(cube)):
print("YES")
return
print("NO") | ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR VAR NUMBER FOR VAR VAR IF VAR NUMBER IF VAR VAR VAR NUMBER IF VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR RETURN NUMBER FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING RETURN FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING RETURN EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = input().split()
c1 = a[0] == a[1] == a[2] == a[3]
c2 = a[8] == a[9] == a[10] == a[11]
c3 = a[12] == a[13] == a[6] == a[7]
c4 = a[4] == a[5] == a[18] == a[19]
c5 = a[16] == a[17] == a[22] == a[23]
c6 = a[20] == a[21] == a[14] == a[15]
c1 = c1
c2 = c2
c7 = a[4] == a[5] == a[14] == a[15]
c8 = a[12] == a[13] == a[22] == a[23]
c9 = a[20] == a[21] == a[18] == a[19]
c10 = a[16] == a[17] == a[6] == a[7]
c11 = a[4] == a[5] == a[6] == a[7]
c12 = a[20] == a[21] == a[22] == a[23]
c13 = a[8] == a[9] == a[17] == a[19]
c14 = a[16] == a[18] == a[0] == a[1]
c15 = a[2] == a[3] == a[12] == a[14]
c16 = a[13] == a[15] == a[10] == a[11]
c11 = c11
c12 = c12
c17 = a[8] == a[9] == a[12] == a[14]
c18 = a[13] == a[15] == a[0] == a[1]
c19 = a[2] == a[3] == a[17] == a[19]
c20 = a[16] == a[18] == a[10] == a[11]
c21 = a[12] == a[13] == a[14] == a[15]
c22 = a[16] == a[17] == a[18] == a[19]
c23 = a[8] == a[10] == a[5] == a[7]
c24 = a[4] == a[6] == a[1] == a[3]
c25 = a[0] == a[2] == a[20] == a[22]
c26 = a[21] == a[23] == a[9] == a[11]
c21 = c21
c22 = c22
c27 = a[8] == a[10] == a[20] == a[22]
c28 = a[21] == a[23] == a[1] == a[3]
c29 = a[0] == a[2] == a[5] == a[7]
c30 = a[4] == a[6] == a[9] == a[11]
case1 = c1 and c2 and c3 and c4 and c5 and c6
case2 = c1 and c2 and c7 and c8 and c9 and c10
case3 = c11 and c12 and c13 and c14 and c15 and c16
case4 = c11 and c12 and c17 and c18 and c19 and c20
case5 = c21 and c22 and c23 and c24 and c25 and c26
case6 = c21 and c22 and c27 and c28 and c29 and c30
if case1 or case2 or case3 or case4 or case5 or case6:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR VAR VAR IF VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = [(1, 5), (3, 7), (5, 9), (7, 11), (9, 24), (11, 22), (22, 3), (24, 1)]
b = [(2, 6), (4, 8), (6, 10), (8, 12), (10, 23), (12, 21), (23, 2), (21, 4)]
c = [(5, 13), (6, 14), (17, 5), (18, 6), (21, 17), (22, 18), (14, 22), (13, 21)]
d = [(7, 15), (8, 16), (19, 7), (20, 8), (23, 19), (24, 20), (16, 24), (15, 23)]
e = [(3, 17), (4, 19), (17, 10), (19, 9), (10, 16), (9, 14), (16, 3), (14, 4)]
f = [(1, 18), (2, 20), (18, 12), (20, 11), (12, 15), (11, 13), (15, 1), (13, 2)]
hh = list(map(int, input().split(" ")))
flag = False
for i in [a, b, c, d, e, f]:
f = True
h = [hh[j] for j in range(24)]
for j, k in i:
h[j - 1] = hh[k - 1]
for j in range(6):
z = []
for k in range(4):
num = j * 4 + k
z.append(h[num])
cnt = 0
for c in range(1, 7):
if c in z:
cnt += 1
if cnt != 1:
f = False
if f:
flag = True
f = True
h = [hh[j] for j in range(24)]
for j, k in i:
h[k - 1] = hh[j - 1]
for j in range(6):
z = []
for k in range(4):
num = j * 4 + k
z.append(h[num])
cnt = 0
for c in range(1, 7):
if c in z:
cnt += 1
if cnt != 1:
f = False
if f:
flag = True
if flag:
print("YES")
else:
print("NO") | ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER FOR VAR LIST VAR VAR VAR VAR VAR VAR ASSIGN VAR NUMBER ASSIGN VAR VAR VAR VAR FUNC_CALL VAR NUMBER FOR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR VAR VAR VAR FUNC_CALL VAR NUMBER FOR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER NUMBER IF VAR VAR VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER IF VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | PMP = [1, 0, 3, 2, 5, 4, 7, 6]
def Pedy(arr1, arr2):
global PMP
for i in range(8):
h = i
if i % 2:
continue
hh = 0
anss = 1
while h != (i - 1 + 8) % 8 and anss:
if arr1[h] != arr2[hh]:
anss = 0
if arr1[h] != arr1[PMP[h]]:
anss = 0
h += 1
hh += 1
if h == 8:
h = 0
if anss and arr1[h] == arr2[hh] and (i == 0 or i == 2 or i == 6):
return 1
return 0
a = list(map(int, input().split()))
b = []
for j in range(6):
i = j * 4
if a[i] == a[i + 1] and a[i + 1] == a[i + 2] and a[i + 2] == a[i + 3]:
b.append(0)
else:
b.append(1)
c = []
c.append(b[0] or b[2])
c.append(b[1] or b[5])
c.append(b[3] or b[4])
if c[0] + c[1] + c[2] == 3 or c[0] + c[1] + c[2] == 1:
print("NO")
if c[0] + c[1] + c[2] == 0:
print("NO")
if c[0] + c[1] + c[2] == 2:
if c[0] + c[1] == 2:
arr1 = []
arr2 = []
arr1.append(a[0])
arr1.append(a[2])
arr1.append(a[4])
arr1.append(a[6])
arr1.append(a[8])
arr1.append(a[10])
arr1.append(a[21])
arr1.append(a[23])
arr2.append(a[1])
arr2.append(a[3])
arr2.append(a[5])
arr2.append(a[7])
arr2.append(a[9])
arr2.append(a[11])
arr2.append(a[20])
arr2.append(a[22])
if Pedy(arr1, arr2):
print("YES")
else:
print("NO")
if c[0] + c[2] == 2:
arr1 = []
arr2 = []
arr1.append(a[0])
arr1.append(a[1])
arr1.append(a[17])
arr1.append(a[19])
arr1.append(a[11])
arr1.append(a[10])
arr1.append(a[14])
arr1.append(a[12])
arr2.append(a[2])
arr2.append(a[3])
arr2.append(a[16])
arr2.append(a[18])
arr2.append(a[9])
arr2.append(a[8])
arr2.append(a[15])
arr2.append(a[13])
if Pedy(arr1, arr2):
print("YES")
else:
print("NO")
if c[1] + c[2] == 2:
arr1 = []
arr2 = []
arr1.append(a[12])
arr1.append(a[13])
arr1.append(a[4])
arr1.append(a[5])
arr1.append(a[16])
arr1.append(a[17])
arr1.append(a[20])
arr1.append(a[21])
arr2.append(a[14])
arr2.append(a[15])
arr2.append(a[6])
arr2.append(a[7])
arr2.append(a[18])
arr2.append(a[19])
arr2.append(a[22])
arr2.append(a[23])
if Pedy(arr1, arr2):
print("YES")
else:
print("NO") | ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR IF BIN_OP VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER VAR IF VAR VAR VAR VAR ASSIGN VAR NUMBER IF VAR VAR VAR VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER IF VAR VAR VAR VAR VAR VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR NUMBER ASSIGN VAR LIST EXPR FUNC_CALL VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER VAR NUMBER IF BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER NUMBER BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR STRING IF BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER NUMBER EXPR FUNC_CALL VAR STRING IF BIN_OP BIN_OP VAR NUMBER VAR NUMBER VAR NUMBER NUMBER IF BIN_OP VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR LIST EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF BIN_OP VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR LIST EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF BIN_OP VAR NUMBER VAR NUMBER NUMBER ASSIGN VAR LIST ASSIGN VAR LIST EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER IF FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | import sys
input = sys.stdin.readline
def read():
return list(map(int, input().split()))
def check(x):
for i in range(0, 24, 4):
if x[i : i + 4] != [x[i]] * 4:
return False
return True
a = read()
if check(a):
print("NO")
quit()
b = list(a)
b[2], b[3], b[16], b[18], b[9], b[8], b[15], b[13] = (
b[15],
b[13],
b[2],
b[3],
b[16],
b[18],
b[9],
b[8],
)
if check(b):
print("YES")
quit()
b = list(a)
b[2], b[3], b[16], b[18], b[9], b[8], b[15], b[13] = (
b[16],
b[18],
b[9],
b[8],
b[15],
b[13],
b[2],
b[3],
)
if check(b):
print("YES")
quit()
b = list(a)
b[0], b[1], b[17], b[19], b[11], b[10], b[14], b[12] = (
b[14],
b[12],
b[0],
b[1],
b[17],
b[19],
b[11],
b[10],
)
if check(b):
print("YES")
quit()
b = list(a)
b[0], b[1], b[17], b[19], b[11], b[10], b[14], b[12] = (
b[17],
b[19],
b[11],
b[10],
b[14],
b[12],
b[0],
b[1],
)
if check(b):
print("YES")
quit()
b = list(a)
b[4], b[5], b[12], b[13], b[20], b[21], b[16], b[17] = (
b[12],
b[13],
b[20],
b[21],
b[16],
b[17],
b[4],
b[5],
)
if check(b):
print("YES")
quit()
b = list(a)
b[4], b[5], b[12], b[13], b[20], b[21], b[16], b[17] = (
b[16],
b[17],
b[4],
b[5],
b[12],
b[13],
b[20],
b[21],
)
if check(b):
print("YES")
quit()
b = list(a)
b[6], b[7], b[14], b[15], b[22], b[23], b[18], b[19] = (
b[14],
b[15],
b[22],
b[23],
b[18],
b[19],
b[6],
b[7],
)
if check(b):
print("YES")
quit()
b = list(a)
b[6], b[7], b[14], b[15], b[22], b[23], b[18], b[19] = (
b[18],
b[19],
b[6],
b[7],
b[14],
b[15],
b[22],
b[23],
)
if check(b):
print("YES")
quit()
b = list(a)
b[1], b[3], b[5], b[7], b[9], b[11], b[22], b[20] = (
b[5],
b[7],
b[9],
b[11],
b[22],
b[20],
b[1],
b[3],
)
if check(b):
print("YES")
quit()
b = list(a)
b[1], b[3], b[5], b[7], b[9], b[11], b[22], b[20] = (
b[22],
b[20],
b[1],
b[3],
b[5],
b[7],
b[9],
b[11],
)
if check(b):
print("YES")
quit()
b = list(a)
b[0], b[2], b[4], b[6], b[8], b[10], b[23], b[21] = (
b[4],
b[6],
b[8],
b[10],
b[23],
b[21],
b[0],
b[2],
)
if check(b):
print("YES")
quit()
b = list(a)
b[0], b[2], b[4], b[6], b[8], b[10], b[23], b[21] = (
b[23],
b[21],
b[0],
b[2],
b[4],
b[6],
b[8],
b[10],
)
if check(b):
print("YES")
quit()
print("NO") | IMPORT ASSIGN VAR VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF VAR VAR BIN_OP VAR NUMBER BIN_OP LIST VAR VAR NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | ll = [int(x) for x in input().split()]
l = ll[:]
def ok(l):
for i in range(6):
for j in range(4):
if l[i * 4 + j] != l[i * 4]:
return
print("YES")
exit(0)
a = l[2]
l[2] = l[16]
l[16] = l[9]
l[9] = l[15]
l[15] = a
a = l[3]
l[3] = l[18]
l[18] = l[8]
l[8] = l[13]
l[13] = a
ok(l)
for i in range(2):
a = l[2]
l[2] = l[16]
l[16] = l[9]
l[9] = l[15]
l[15] = a
a = l[3]
l[3] = l[18]
l[18] = l[8]
l[8] = l[13]
l[13] = a
ok(l)
l = ll[:]
a = l[12]
l[12] = l[11]
l[11] = l[16]
l[16] = l[4]
l[4] = a
a = l[13]
l[13] = l[10]
l[10] = l[17]
l[17] = l[5]
l[5] = a
ok(l)
for i in range(2):
a = l[12]
l[12] = l[11]
l[11] = l[16]
l[16] = l[4]
l[4] = a
a = l[13]
l[13] = l[10]
l[10] = l[17]
l[17] = l[5]
l[5] = a
ok(l)
l = ll[:]
a = l[6]
l[6] = l[18]
l[18] = l[22]
l[22] = l[14]
l[14] = a
a = l[7]
l[7] = l[19]
l[19] = l[23]
l[23] = l[15]
l[15] = a
ok(l)
for i in range(2):
a = l[6]
l[6] = l[18]
l[18] = l[22]
l[22] = l[14]
l[14] = a
a = l[7]
l[7] = l[19]
l[19] = l[23]
l[23] = l[15]
l[15] = a
ok(l)
l = ll[:]
a = l[0]
l[0] = l[4]
l[4] = l[8]
l[8] = l[23]
l[23] = a
a = l[2]
l[2] = l[6]
l[6] = l[10]
l[10] = l[21]
l[21] = a
ok(l)
for i in range(2):
a = l[0]
l[0] = l[4]
l[4] = l[8]
l[8] = l[23]
l[23] = a
a = l[2]
l[2] = l[6]
l[6] = l[10]
l[10] = l[21]
l[21] = a
ok(l)
print("NO") | ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR VAR FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP BIN_OP VAR NUMBER VAR VAR BIN_OP VAR NUMBER RETURN EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR ASSIGN VAR VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | faces = [
[5, 6, 17, 18, 21, 22, 13, 14],
[7, 8, 19, 20, 23, 24, 15, 16],
[1, 3, 5, 7, 9, 11, 24, 22],
[2, 4, 6, 8, 10, 12, 23, 21],
[3, 4, 17, 19, 10, 9, 16, 14],
[1, 2, 18, 20, 12, 11, 15, 13],
]
cube = input().split(" ")
def legit(cube):
for i in range(6):
for j in range(4):
if cube[4 * i] != cube[4 * i + j]:
return False
return True
t = False
for rotato in faces:
cubea = cube.copy()
for i in range(8):
cubea[rotato[i] - 1] = cube[rotato[(i + 2) % 8] - 1]
cubeb = cubea.copy()
for i in range(8):
cubeb[rotato[i] - 1] = cubea[rotato[(i + 2) % 8] - 1]
cubec = cubeb.copy()
for i in range(8):
cubec[rotato[i] - 1] = cubeb[rotato[(i + 2) % 8] - 1]
if legit(cubea) or legit(cubec):
t = True
if not t:
print("NO")
else:
print("YES") | ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL VAR STRING FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP NUMBER VAR VAR BIN_OP BIN_OP NUMBER VAR VAR RETURN NUMBER RETURN NUMBER ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR BIN_OP VAR VAR NUMBER VAR BIN_OP VAR BIN_OP BIN_OP VAR NUMBER NUMBER NUMBER IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | line = list(map(int, input().split()))
yes = False
q = [1, -1]
if line[4] == line[5] and line[5] == line[6] and line[6] == line[7]:
if line[20] == line[21] and line[21] == line[22] and line[22] == line[23]:
can = True
c1 = []
if line[15] != line[13]:
can = False
else:
c1 += [line[15]]
if line[3] != line[2]:
can = False
else:
c1 += [line[3]]
if line[16] != line[18]:
can = False
else:
c1 += [line[16]]
if line[8] != line[9]:
can = False
else:
c1 += [line[8]]
c2 = []
if line[12] != line[14]:
can = False
else:
c2 += [line[14]]
if line[0] != line[1]:
can = False
else:
c2 += [line[1]]
if line[17] != line[19]:
can = False
else:
c2 += [line[19]]
if line[10] != line[11]:
can = False
else:
c2 += [line[11]]
if can:
for i in range(2):
c3 = []
for j in range(4):
c3 += [c1[(q[i] + j) % 4]]
if c3 == c2:
yes = True
if line[0] == line[1] and line[1] == line[2] and line[2] == line[3]:
if line[8] == line[9] and line[9] == line[10] and line[10] == line[11]:
can = True
c1 = []
if line[12] != line[13]:
can = False
else:
c1 += [line[12]]
if line[4] != line[5]:
can = False
else:
c1 += [line[4]]
if line[16] != line[17]:
can = False
else:
c1 += [line[16]]
if line[20] != line[21]:
can = False
else:
c1 += [line[21]]
c2 = []
if line[14] != line[15]:
can = False
else:
c2 += [line[14]]
if line[6] != line[7]:
can = False
else:
c2 += [line[7]]
if line[18] != line[19]:
can = False
else:
c2 += [line[19]]
if line[22] != line[23]:
can = False
else:
c2 += [line[23]]
if can:
for i in range(2):
c3 = []
for j in range(4):
c3 += [c1[(q[i] + j) % 4]]
if c3 == c2:
yes = True
if line[12] == line[13] and line[13] == line[14] and line[14] == line[15]:
if line[16] == line[17] and line[17] == line[18] and line[18] == line[19]:
can = True
c1 = []
if line[0] != line[2]:
can = False
else:
c1 += [line[2]]
if line[4] != line[6]:
can = False
else:
c1 += [line[4]]
if line[8] != line[10]:
can = False
else:
c1 += [line[10]]
if line[23] != line[21]:
can = False
else:
c1 += [line[21]]
c2 = []
if line[1] != line[3]:
can = False
else:
c2 += [line[1]]
if line[5] != line[7]:
can = False
else:
c2 += [line[7]]
if line[11] != line[9]:
can = False
else:
c2 += [line[9]]
if line[22] != line[20]:
can = False
else:
c2 += [line[20]]
if can:
for i in range(2):
c3 = []
for j in range(4):
c3 += [c1[(q[i] + j) % 4]]
if c3 == c2:
yes = True
if yes:
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR LIST NUMBER NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER ASSIGN VAR LIST IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER VAR LIST VAR BIN_OP BIN_OP VAR VAR VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER ASSIGN VAR LIST IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER VAR LIST VAR BIN_OP BIN_OP VAR VAR VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR LIST IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER ASSIGN VAR LIST IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR LIST VAR NUMBER IF VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER VAR LIST VAR BIN_OP BIN_OP VAR VAR VAR NUMBER IF VAR VAR ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def eq(cube, a, b, c, d):
return cube[a] == cube[b] and cube[b] == cube[c] and cube[c] == cube[d]
opp = [2, 5, 0, 4, 3, 1]
cube = input().strip().split()
for i in range(6):
if (
cube[4 * i + 0] == cube[4 * i + 1]
and cube[4 * i + 2] == cube[4 * i + 1]
and cube[4 * i + 2] == cube[4 * i + 3]
):
if (
cube[4 * opp[i] + 0] == cube[4 * opp[i] + 1]
and cube[4 * opp[i] + 2] == cube[4 * opp[i] + 1]
and cube[4 * opp[i] + 2] == cube[4 * opp[i] + 3]
):
if i == 0 or i == opp[0]:
if cube[4] == cube[5] and cube[4] == cube[18] and cube[18] == cube[19]:
if (
cube[16] == cube[17]
and cube[17] == cube[22]
and cube[22] == cube[23]
):
if (
cube[20] == cube[21]
and cube[21] == cube[14]
and cube[14] == cube[15]
):
print("YES")
exit()
if cube[4] == cube[5] and cube[4] == cube[15] and cube[14] == cube[15]:
if (
cube[12] == cube[13]
and cube[12] == cube[23]
and cube[22] == cube[23]
):
if (
cube[20] == cube[21]
and cube[18] == cube[19]
and cube[20] == cube[18]
):
print("YES")
exit()
if i == 1 or i == opp[1]:
if eq(cube, 2, 3, 12, 14):
if eq(cube, 13, 15, 10, 11):
if eq(cube, 8, 9, 19, 17):
print("YES")
exit()
if (
eq(cube, 2, 3, 17, 19)
and eq(cube, 16, 18, 10, 11)
and eq(cube, 8, 9, 12, 14)
):
print("YES")
exit()
if i == 3 or i == opp[3]:
if (
eq(cube, 4, 6, 1, 3)
and eq(cube, 0, 2, 20, 22)
and eq(cube, 21, 23, 9, 11)
):
print("YES")
exit()
if (
eq(cube, 4, 6, 9, 11)
and eq(cube, 8, 10, 20, 22)
and eq(cube, 21, 23, 1, 3)
):
print("YES")
exit()
print("NO") | FUNC_DEF RETURN VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR NUMBER VAR BIN_OP BIN_OP NUMBER VAR VAR NUMBER IF VAR NUMBER VAR VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF VAR NUMBER VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER IF FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER IF FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF VAR NUMBER VAR VAR NUMBER IF FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR IF FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | a = [
[1, 3, 5, 7, 9, 11, 24, 22],
[2, 4, 6, 8, 10, 12, 23, 21],
[13, 14, 5, 6, 17, 18, 21, 22],
[15, 16, 7, 8, 19, 20, 23, 24],
[2, 1, 13, 15, 11, 12, 20, 18],
[4, 3, 14, 16, 9, 10, 19, 17],
]
cube = [0] + list(map(int, input().split()))
def rubik(cube):
if (
cube[1] == cube[2] == cube[3] == cube[4]
and cube[5] == cube[6] == cube[7] == cube[8]
and cube[9] == cube[10] == cube[11] == cube[12]
and cube[13] == cube[14] == cube[15] == cube[16]
and cube[17] == cube[18] == cube[19] == cube[20]
and cube[21] == cube[22] == cube[23] == cube[24]
):
return True
else:
return False
for row in a:
b = cube[:]
for i in range(8):
b[row[i]] = cube[row[(i + 2) % 8]]
if rubik(b):
print("YES")
break
b = cube[:]
for i in range(8):
b[row[i]] = cube[row[(8 + i - 2) % 8]]
if rubik(b):
print("YES")
break
else:
print("NO") | ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN NUMBER RETURN NUMBER FOR VAR VAR ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR VAR VAR BIN_OP BIN_OP VAR NUMBER NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING ASSIGN VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR VAR VAR BIN_OP BIN_OP BIN_OP NUMBER VAR NUMBER NUMBER IF FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | colors = ["SHIT"] + list(map(int, input().split()))
faces = [
(1, 2, 3, 4),
(5, 6, 7, 8),
(9, 10, 11, 12),
(13, 14, 15, 16),
(17, 18, 19, 20),
(21, 22, 23, 24),
]
def is_good(colors):
return all([all([(colors[i] == colors[face[0]]) for i in face]) for face in faces])
rotations = {
(1, 2, 3, 4): ([13, 5, 17, 21], [14, 6, 18, 22]),
(5, 6, 7, 8): ([14, 9, 19, 4], [16, 10, 17, 3]),
(9, 10, 11, 12): ([7, 15, 23, 19], [8, 16, 24, 20]),
(13, 14, 15, 16): ([5, 1, 24, 9], [7, 3, 22, 11]),
(17, 18, 19, 20): ([6, 10, 23, 2], [8, 12, 21, 4]),
(21, 22, 23, 24): ([1, 18, 12, 15], [2, 20, 11, 13]),
}
def rotate(colors, face):
result1 = colors.copy()
rule1, rule2 = rotations[face]
for i in range(4):
result1[rule1[i]] = colors[rule1[(i + 1) % 4]]
result1[rule2[i]] = colors[rule2[(i + 1) % 4]]
result2 = colors.copy()
for i in range(4):
result2[rule1[(i + 1) % 4]] = colors[rule1[i]]
result2[rule2[(i + 1) % 4]] = colors[rule2[i]]
return result1, result2
for face in faces:
rotated = rotate(colors, face)
if is_good(rotated[0]) or is_good(rotated[1]):
print("YES")
break
else:
print("NO") | ASSIGN VAR BIN_OP LIST STRING FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR VAR VAR VAR NUMBER VAR VAR VAR VAR ASSIGN VAR DICT NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR ASSIGN VAR VAR VAR VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR VAR VAR VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR VAR VAR VAR VAR BIN_OP BIN_OP VAR NUMBER NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR VAR VAR ASSIGN VAR VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR VAR VAR RETURN VAR VAR FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR VAR NUMBER FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def solvable(la):
colors_faces = [set() for _ in range(6)]
for i, a in zip(list(range(50)), la):
face = i // 4
colors_faces[face].add(a)
if len(colors_faces[face]) > 2:
return False
ones = []
twos = []
for i, face_set in enumerate(colors_faces):
if len(face_set) == 1:
ones.append(i)
else:
twos.append(i)
twos.sort()
possibilities = [[0, 1, 2, 5], [0, 2, 3, 4], [1, 3, 4, 5]]
if twos not in possibilities:
return False
yep = False
if twos == [0, 1, 2, 5]:
yep = (
la[0] == la[2]
and la[2] == la[5]
and la[5] == la[7]
and la[1] == la[3]
and la[3] == la[21]
and la[21] == la[23]
and la[4] == la[6]
and la[6] == la[9]
and la[9] == la[11]
and la[8] == la[10]
and la[10] == la[20]
and la[20] == la[22]
or la[0] == la[2]
and la[2] == la[20]
and la[20] == la[22]
and la[1] == la[3]
and la[3] == la[4]
and la[4] == la[6]
and la[5] == la[7]
and la[7] == la[8]
and la[8] == la[10]
and la[9] == la[11]
and la[11] == la[21]
and la[21] == la[23]
)
elif twos == [0, 2, 3, 4]:
yep = (
la[0] == la[1]
and la[1] == la[16]
and la[16] == la[18]
and la[17] == la[19]
and la[19] == la[9]
and la[9] == la[8]
and la[10] == la[11]
and la[11] == la[15]
and la[15] == la[13]
and la[2] == la[3]
and la[3] == la[12]
and la[12] == la[14]
or la[0] == la[1]
and la[1] == la[13]
and la[13] == la[15]
and la[2] == la[3]
and la[3] == la[17]
and la[17] == la[19]
and la[12] == la[14]
and la[14] == la[8]
and la[8] == la[9]
and la[10] == la[11]
and la[11] == la[16]
and la[16] == la[18]
)
elif twos == [1, 3, 4, 5]:
yep = (
la[12] == la[13]
and la[13] == la[6]
and la[6] == la[7]
and la[4] == la[5]
and la[5] == la[18]
and la[18] == la[19]
and la[16] == la[17]
and la[17] == la[22]
and la[22] == la[23]
and la[20] == la[21]
and la[21] == la[14]
and la[14] == la[15]
or la[14] == la[15]
and la[4] == la[5]
and la[14] == la[4]
and la[6] == la[7]
and la[6] == la[16]
and la[16] == la[17]
and la[18] == la[19]
and la[19] == la[20]
and la[20] == la[21]
and la[12] == la[13]
and la[13] == la[22]
and la[22] == la[23]
)
return yep
la = list(map(int, input().split()))
print("YES" if solvable(la) else "NO") | FUNC_DEF ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL VAR NUMBER FOR VAR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR IF FUNC_CALL VAR VAR VAR NUMBER RETURN NUMBER ASSIGN VAR LIST ASSIGN VAR LIST FOR VAR VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER IF VAR VAR RETURN NUMBER ASSIGN VAR NUMBER IF VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR STRING STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def all_is(l):
f = l[1]
for i in range(2, len(l)):
if l[i] == f or l[i] == None:
pass
else:
return False
return True
lst = list(map(int, input().split(" ")))
u, f, d, l, r, t = lst[:4], lst[4:8], lst[8:12], lst[12:16], lst[16:20], lst[20:]
u.insert(0, None)
f.insert(0, None)
d.insert(0, None)
l.insert(0, None)
r.insert(0, None)
t.insert(0, None)
if (
all_is(u)
and not all_is(f)
and all_is(d)
and not all_is(l)
and not all_is(r)
and not all_is(t)
):
if (
l[1] == l[2] == f[3] == f[4]
and f[1] == f[2] == r[3] == r[4]
and r[1] == r[2] == t[3] == t[4]
and t[1] == t[2] == l[3] == l[4]
or l[3] == l[4] == f[1] == f[2]
and f[3] == f[4] == r[1] == r[2]
and r[3] == r[4] == t[1] == t[2]
and t[3] == t[4] == l[1] == l[2]
):
print("YES")
else:
print("NO")
elif (
not all_is(u)
and all_is(f)
and not all_is(d)
and not all_is(l)
and not all_is(r)
and all_is(t)
):
if (
l[1] == l[3] == u[3] == u[4]
and u[1] == u[2] == r[1] == r[3]
and r[2] == r[4] == d[1] == d[2]
and d[3] == d[4] == l[2] == l[4]
or l[2] == l[4] == u[1] == u[2]
and u[3] == u[4] == r[2] == r[4]
and r[1] == r[3] == d[3] == d[4]
and d[1] == d[2] == l[1] == l[3]
):
print("YES")
else:
print("NO")
elif (
not all_is(u)
and not all_is(f)
and not all_is(d)
and all_is(l)
and all_is(r)
and not all_is(t)
):
if (
f[1] == f[3] == u[2] == u[4]
and u[1] == u[3] == t[1] == t[3]
and t[2] == t[4] == d[2] == d[4]
and d[1] == d[3] == f[2] == f[4]
or f[2] == f[4] == u[1] == u[3]
and u[2] == u[4] == t[2] == t[4]
and t[1] == t[3] == d[1] == d[3]
and d[2] == d[4] == f[1] == f[3]
):
print("YES")
else:
print("NO")
else:
print("NO") | FUNC_DEF ASSIGN VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR NONE RETURN NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR VAR VAR VAR VAR VAR VAR NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER NUMBER VAR NUMBER EXPR FUNC_CALL VAR NUMBER NONE EXPR FUNC_CALL VAR NUMBER NONE EXPR FUNC_CALL VAR NUMBER NONE EXPR FUNC_CALL VAR NUMBER NONE EXPR FUNC_CALL VAR NUMBER NONE EXPR FUNC_CALL VAR NUMBER NONE IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR FUNC_CALL VAR VAR IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | colors = list(map(int, input().split()))
faces = {}
faces["top"] = colors[:4]
faces["front"] = colors[4:8]
faces["bottom"] = colors[8:12]
faces["left"] = colors[12:16]
faces["right"] = colors[16:20]
faces["back"] = [colors[21], colors[20], colors[23], colors[22]]
status = {}
for face in faces.keys():
colors = faces[face]
if max(colors) == min(colors):
status[face] = "ok"
elif colors[0] == colors[1] and colors[2] == colors[3]:
status[face] = "h"
elif colors[0] == colors[2] and colors[1] == colors[3]:
status[face] = "v"
else:
status[face] = "bad"
if "bad" in status.values():
print("NO")
elif (
status["top"] == status["bottom"] == "ok"
and status["front"] == status["left"] == status["right"] == status["back"] == "h"
):
if (
faces["front"][0] == faces["left"][3]
and faces["left"][0] == faces["back"][3]
and faces["back"][0] == faces["right"][3]
and faces["right"][0] == faces["front"][3]
or faces["front"][0] == faces["right"][3]
and faces["right"][0] == faces["back"][3]
and faces["back"][0] == faces["left"][3]
and faces["left"][0] == faces["front"][3]
):
print("YES")
else:
print("NO")
elif (
status["left"] == status["right"] == "ok"
and status["front"] == status["top"] == status["bottom"] == status["back"] == "v"
):
if (
faces["front"][0] == faces["top"][3]
and faces["top"][0] == faces["back"][3]
and faces["back"][0] == faces["bottom"][3]
and faces["bottom"][0] == faces["front"][3]
or faces["front"][0] == faces["bottom"][3]
and faces["bottom"][0] == faces["back"][3]
and faces["back"][0] == faces["top"][3]
and faces["top"][0] == faces["front"][3]
):
print("YES")
else:
print("NO")
elif (
status["front"] == status["back"] == "ok"
and status["left"] == status["right"] == "v"
and status["top"] == status["bottom"] == "h"
):
if (
faces["top"][0] == faces["left"][1]
and faces["left"][0] == faces["bottom"][0]
and faces["bottom"][3] == faces["right"][0]
and faces["right"][3] == faces["top"][3]
or faces["top"][0] == faces["right"][0]
and faces["right"][1] == faces["bottom"][0]
and faces["bottom"][3] == faces["left"][1]
and faces["left"][0] == faces["top"][3]
):
print("YES")
else:
print("NO")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT ASSIGN VAR STRING VAR NUMBER ASSIGN VAR STRING VAR NUMBER NUMBER ASSIGN VAR STRING VAR NUMBER NUMBER ASSIGN VAR STRING VAR NUMBER NUMBER ASSIGN VAR STRING VAR NUMBER NUMBER ASSIGN VAR STRING LIST VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR DICT FOR VAR FUNC_CALL VAR ASSIGN VAR VAR VAR IF FUNC_CALL VAR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR STRING IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR STRING IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER ASSIGN VAR VAR STRING ASSIGN VAR VAR STRING IF STRING FUNC_CALL VAR EXPR FUNC_CALL VAR STRING IF VAR STRING VAR STRING STRING VAR STRING VAR STRING VAR STRING VAR STRING STRING IF VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF VAR STRING VAR STRING STRING VAR STRING VAR STRING VAR STRING VAR STRING STRING IF VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING IF VAR STRING VAR STRING STRING VAR STRING VAR STRING STRING VAR STRING VAR STRING STRING IF VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER VAR STRING NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def g(l1, l2):
dic = {}
for ls in [l1, l2]:
ls.append(ls[0])
ls.append(ls[1])
num = 2 if ls == l1 else 1
for i in range(len(ls) - num):
dic[ls[i + num]] = ls[i]
return dic, dict((val, key) for key, val in dic.items())
left, left_ = g([1, 3, 5, 7, 9, 11, 24, 22], [13, 14, 16, 15])
top, top_ = g([13, 14, 5, 6, 17, 18, 21, 22], [1, 3, 4, 2])
right, right_ = g([4, 2, 21, 23, 12, 10, 8, 6], [17, 18, 20, 19])
bottom, bottom_ = g([15, 16, 7, 8, 19, 20, 23, 24], [9, 10, 12, 11])
back, back_ = g([1, 2, 18, 20, 12, 11, 15, 13], [21, 23, 24, 22])
center, center_ = g([3, 4, 17, 19, 10, 9, 16, 14], [5, 6, 8, 7])
all_dics = [
left,
left_,
right,
right_,
top,
top_,
bottom,
bottom_,
back,
back_,
center,
center_,
]
vals = [int(elem) for elem in input().split(" ")]
def f(vals):
for dic in all_dics:
aux = list(vals)
for val in dic:
aux[val - 1] = vals[dic[val] - 1]
for i in range(6):
found = True
if len(set(aux[4 * i : 4 * (i + 1)])) != 1:
found = False
break
if found:
print("YES")
return
print("NO")
f(vals) | FUNC_DEF ASSIGN VAR DICT FOR VAR LIST VAR VAR EXPR FUNC_CALL VAR VAR NUMBER EXPR FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR VAR ASSIGN VAR VAR BIN_OP VAR VAR VAR VAR RETURN VAR FUNC_CALL VAR VAR VAR VAR VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR VAR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING FUNC_DEF FOR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FOR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER VAR BIN_OP VAR VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER ASSIGN VAR NUMBER IF FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP NUMBER VAR BIN_OP NUMBER BIN_OP VAR NUMBER NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR STRING RETURN EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR VAR |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | S = 24
class Permutation:
def __init__(self, C=None):
if isinstance(C, list):
assert len(C) == S
self.P = C
else:
self.P = list(range(S))
if isinstance(C, tuple):
for i in range(len(C)):
self.P[C[i]] = C[(i + 1) % len(C)]
self.P = tuple(self.P)
def __getitem__(self, i):
return self.P[i]
def __mul__(self, A):
res = [0] * S
for i in range(S):
res[i] = self[A[i]]
return Permutation(res)
def __hash__(self):
return hash(self.P)
def __eq__(self, A):
return self.P == A.P
def decomp(self):
D = []
seen = [False] * S
for i0 in range(S):
if not seen[i0]:
seen[i0] = True
C = [i0]
i = self[i0]
while i != i0:
seen[i] = True
C.append(i)
i = self[i]
D.append(C)
return D
Gen = []
Gen.append(
Permutation((0, 1, 2, 3))
* Permutation((4, 9, 14, 19))
* Permutation((7, 8, 13, 18))
)
Gen.append(
Permutation((4, 5, 6, 7))
* Permutation((1, 17, 21, 9))
* Permutation((2, 18, 22, 10))
)
Gen.append(
Permutation((8, 9, 10, 11))
* Permutation((15, 3, 7, 21))
* Permutation((14, 2, 6, 20))
)
Gen.append(
Permutation((12, 13, 14, 15))
* Permutation((20, 16, 0, 8))
* Permutation((23, 19, 3, 11))
)
Gen.append(
Permutation((16, 17, 18, 19))
* Permutation((13, 23, 5, 1))
* Permutation((12, 22, 4, 0))
)
Gen.append(
Permutation((20, 21, 22, 23))
* Permutation((12, 11, 6, 17))
* Permutation((15, 10, 5, 16))
)
def solved(C, P):
for i in range(0, 24, 4):
if any(C[P[i + k]] != C[P[i]] for k in range(1, 4)):
return False
return True
def main():
C = list(map(int, input().split()))
R = Permutation(
[
5,
7,
6,
4,
9,
11,
10,
8,
13,
15,
14,
12,
1,
3,
2,
0,
17,
19,
18,
16,
21,
23,
22,
20,
]
)
for i in range(len(Gen)):
Gen.append(Gen[i] * Gen[i] * Gen[i])
print("YES" if any(solved(C, R * g) for g in Gen) else "NO")
main() | ASSIGN VAR NUMBER CLASS_DEF FUNC_DEF NONE IF FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF FUNC_CALL VAR VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR BIN_OP BIN_OP VAR NUMBER FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_DEF RETURN VAR VAR FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR RETURN FUNC_CALL VAR VAR FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_DEF RETURN VAR VAR FUNC_DEF ASSIGN VAR LIST ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR VAR NUMBER ASSIGN VAR LIST VAR ASSIGN VAR VAR VAR WHILE VAR VAR ASSIGN VAR VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR EXPR FUNC_CALL VAR VAR RETURN VAR ASSIGN VAR LIST EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_CALL VAR NUMBER NUMBER NUMBER NUMBER FUNC_DEF FOR VAR FUNC_CALL VAR NUMBER NUMBER NUMBER IF FUNC_CALL VAR VAR VAR BIN_OP VAR VAR VAR VAR VAR VAR FUNC_CALL VAR NUMBER NUMBER RETURN NUMBER RETURN NUMBER FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR LIST NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR VAR STRING STRING EXPR FUNC_CALL VAR |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | from sys import stdin
ocube = [int(x) for x in stdin.readline().strip().split()]
ocube.insert(0, 0)
def UL(array):
cube = []
for i in range(len(array)):
cube.append(array[i])
cube[5:7] = array[17:19]
cube[17:19] = array[21:23]
cube[21:23] = array[13:15]
cube[13:15] = array[5:7]
return cube
def UR(array):
cube = []
for i in range(len(array)):
cube.append(array[i])
cube[5:7] = array[13:15]
cube[17:19] = array[5:7]
cube[21:23] = array[17:19]
cube[13:15] = array[21:23]
return cube
def RU(array):
cube = []
for i in range(len(array)):
cube.append(array[i])
cube[6] = array[10]
cube[8] = array[12]
cube[23] = array[2]
cube[21] = array[4]
cube[10] = array[23]
cube[12] = array[21]
cube[2] = array[6]
cube[4] = array[8]
return cube
def RD(array):
cube = []
for i in range(len(array)):
cube.append(array[i])
cube[6] = array[2]
cube[8] = array[4]
cube[23] = array[10]
cube[21] = array[12]
cube[10] = array[6]
cube[12] = array[8]
cube[2] = array[23]
cube[4] = array[21]
return cube
def FL(array):
cube = []
for i in range(len(array)):
cube.append(array[i])
cube[3] = array[17]
cube[4] = array[19]
cube[17] = array[10]
cube[19] = array[9]
cube[9] = array[14]
cube[10] = array[16]
cube[14] = array[4]
cube[16] = array[3]
return cube
def FR(array):
cube = []
for i in range(len(array)):
cube.append(array[i])
cube[3] = array[16]
cube[4] = array[14]
cube[17] = array[3]
cube[19] = array[4]
cube[9] = array[19]
cube[10] = array[17]
cube[14] = array[9]
cube[16] = array[10]
return cube
def check(array):
i = 1
control = True
while i <= 24:
if (
array[i] == array[i + 1]
and array[i + 1] == array[i + 2]
and array[i + 2] == array[i + 3]
):
i += 4
control = control and True
else:
i += 4
control = control and False
return control
if (
check(UL(ocube))
or check(UR(ocube))
or check(RU(ocube))
or check(RD(ocube))
or check(FL(ocube))
or check(FR(ocube))
):
print("YES")
else:
print("NO") | ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR NUMBER NUMBER FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER RETURN VAR FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER NUMBER VAR NUMBER NUMBER RETURN VAR FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR LIST FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER RETURN VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR NUMBER IF VAR VAR VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER VAR NUMBER ASSIGN VAR VAR NUMBER RETURN VAR IF FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
During the breaks between competitions, top-model Izabella tries to develop herself and not to be bored. For example, now she tries to solve Rubik's cube 2x2x2.
It's too hard to learn to solve Rubik's cube instantly, so she learns to understand if it's possible to solve the cube in some state using 90-degrees rotation of one face of the cube in any direction.
To check her answers she wants to use a program which will for some state of cube tell if it's possible to solve it using one rotation, described above.
Cube is called solved if for each face of cube all squares on it has the same color.
https://en.wikipedia.org/wiki/Rubik's_Cube
-----Input-----
In first line given a sequence of 24 integers a_{i} (1 ≤ a_{i} ≤ 6), where a_{i} denotes color of i-th square. There are exactly 4 occurrences of all colors in this sequence.
-----Output-----
Print «YES» (without quotes) if it's possible to solve cube using one rotation and «NO» (without quotes) otherwise.
-----Examples-----
Input
2 5 4 6 1 3 6 2 5 5 1 2 3 5 3 1 1 2 4 6 6 4 3 4
Output
NO
Input
5 3 5 3 2 5 2 5 6 2 6 2 4 4 4 4 1 1 1 1 6 3 6 3
Output
YES
-----Note-----
In first test case cube looks like this: [Image]
In second test case cube looks like this: [Image]
It's possible to solve cube by rotating face with squares with numbers 13, 14, 15, 16. | def main():
raw = list(int(x) - 1 for x in input().split())
d = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16],
[17, 18, 19, 20],
[21, 22, 23, 24],
]
l = []
for i in range(6):
l.append(raw[4 * i : 4 * i + 4])
def rt(x, y):
print(x, y)
if x == (y + 1) % 6 or x == (y + 2) % 6 or x == (y + 3) % 6:
return True
else:
return False
c = 0
for face in l:
if face[0] == face[1] == face[2] == face[3]:
c += 1
elif face[0] == face[1] and face[2] == face[3]:
pass
elif face[0] == face[2] and face[1] == face[3]:
pass
else:
return "NO"
if c != 2:
return "NO"
d = []
d += [
[
[[0, 0], [0, 2], [1, 1], [1, 3]],
[[1, 0], [1, 2], [2, 1], [2, 3]],
[[2, 0], [2, 2], [5, 0], [5, 2]],
[[5, 1], [5, 3], [0, 1], [0, 3]],
]
]
d += [
[
[[0, 1], [0, 3], [1, 0], [1, 2]],
[[1, 1], [1, 3], [2, 0], [2, 2]],
[[2, 1], [2, 3], [5, 1], [5, 3]],
[[5, 0], [5, 2], [0, 0], [0, 2]],
]
]
d += [
[
[[1, 0], [1, 1], [4, 2], [4, 3]],
[[4, 0], [4, 1], [5, 2], [5, 3]],
[[5, 0], [5, 1], [3, 2], [3, 3]],
[[3, 0], [3, 1], [1, 2], [1, 3]],
]
]
d += [
[
[[1, 2], [1, 3], [4, 0], [4, 1]],
[[4, 2], [4, 3], [5, 0], [5, 1]],
[[5, 2], [5, 3], [3, 0], [3, 1]],
[[3, 2], [3, 3], [1, 0], [1, 1]],
]
]
d += [
[
[[0, 0], [0, 1], [4, 0], [4, 2]],
[[4, 1], [4, 3], [2, 0], [2, 1]],
[[2, 2], [2, 3], [3, 1], [3, 3]],
[[3, 0], [3, 2], [0, 2], [0, 3]],
]
]
d += [
[
[[0, 2], [0, 3], [4, 1], [4, 3]],
[[4, 0], [4, 2], [2, 2], [2, 3]],
[[2, 0], [2, 1], [3, 0], [3, 2]],
[[3, 1], [3, 3], [0, 0], [0, 1]],
]
]
for dd in d:
flag = True
for i in dd:
if (
not l[i[0][0]][i[0][1]]
== l[i[1][0]][i[1][1]]
== l[i[2][0]][i[2][1]]
== l[i[3][0]][i[3][1]]
):
flag = False
break
if flag:
return "YES"
return "NO"
print(main()) | FUNC_DEF ASSIGN VAR FUNC_CALL VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER LIST NUMBER NUMBER NUMBER NUMBER ASSIGN VAR LIST FOR VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP NUMBER VAR BIN_OP BIN_OP NUMBER VAR NUMBER FUNC_DEF EXPR FUNC_CALL VAR VAR VAR IF VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR NUMBER NUMBER VAR BIN_OP BIN_OP VAR NUMBER NUMBER RETURN NUMBER RETURN NUMBER ASSIGN VAR NUMBER FOR VAR VAR IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER VAR NUMBER RETURN STRING IF VAR NUMBER RETURN STRING ASSIGN VAR LIST VAR LIST LIST LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER VAR LIST LIST LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER VAR LIST LIST LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER VAR LIST LIST LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER VAR LIST LIST LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER VAR LIST LIST LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER LIST NUMBER NUMBER FOR VAR VAR ASSIGN VAR NUMBER FOR VAR VAR IF VAR VAR NUMBER NUMBER VAR NUMBER NUMBER VAR VAR NUMBER NUMBER VAR NUMBER NUMBER VAR VAR NUMBER NUMBER VAR NUMBER NUMBER VAR VAR NUMBER NUMBER VAR NUMBER NUMBER ASSIGN VAR NUMBER IF VAR RETURN STRING RETURN STRING EXPR FUNC_CALL VAR FUNC_CALL VAR |
Some people are just moody, you just cannot reason with them.
Same goes with Natural Numbers. Some of them ultimely want to become 1 or 4 and will evolve infinite times if they have to, to become what they want to. To evolve, they use a function F such that N = F(N). Function F(N) is defined as :
F(N) = sum_of_digits(N^
2)
So, your task is that given a number N, output if it is possible for it to ultimately become {1 or 4} or not.
Input:
First line contains T which is the number of test cases.
T lines follow each with an integer N.
Output:
For each N output "YES" or "NO" if the number can achieve desired goal or not.
Constraints:
1 ≤ T ≤ 10^6
1≤ N ≤ 10^9
Scoring:
1 ≤ T ≤ 10^6,1 ≤ N ≤ 10^3:(30 pts)
1 ≤ T ≤ 10^6,1 ≤ N ≤ 10^6:(30 pts)
1 ≤ T ≤ 10^6,1 ≤ N ≤ 10^9:(40 pts)
Note:
Large IO. Use scanf/printf(in C/C++).
SAMPLE INPUT
4
1
2
3
8
SAMPLE OUTPUT
YES
YES
NO
YES
Explanation
Case 1: 1. As 1 is already at the desired destination state, the answer is YES.
Case 2: 2. After squaring this becomes 4. DigitSum of 4 is 4 which is the new state and also the desired destination state. Hence YES.
Case 3: 3. Figure this out yourself!
Case 4: 8 >> [64] >> 10 >> [100] >>1. Thus answer is YES. | mem = {}
def sum_digits3(n):
n = n**2
r = 0
while n:
r, n = r + n % 10, n // 10
return r
def findnature(n):
if n in mem:
return mem[n]
if n == 1 or n == 4:
return 1
if n == 9 or n == 13:
return -1
ans = findnature(sum_digits3(n))
mem[n] = ans
return ans
for t in range(int(input())):
if findnature(int(input())) == 1:
print("YES")
else:
print("NO") | ASSIGN VAR DICT FUNC_DEF ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER WHILE VAR ASSIGN VAR VAR BIN_OP VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER RETURN VAR FUNC_DEF IF VAR VAR RETURN VAR VAR IF VAR NUMBER VAR NUMBER RETURN NUMBER IF VAR NUMBER VAR NUMBER RETURN NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR IF FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER EXPR FUNC_CALL VAR STRING EXPR FUNC_CALL VAR STRING |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | for t in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
count = 0
for i in range(n):
for j in range(n):
if i != j:
if i <= j and a[i] >= a[j] or i >= j and a[i] <= a[j]:
count += 1
print(count // 2) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR IF VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | for j in range(int(input())):
n = int(input())
s = [int(i) for i in input().split()]
count = 0
for i in range(n - 1):
x = s[i]
for j in range(i + 1, n):
if s[j] <= x:
count += 1
print(count) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | import sys
def get_ints():
return map(int, sys.stdin.readline().strip().split())
def get_ls():
return list(map(int, sys.stdin.readline().strip().split()))
def main():
for _ in range(int(input())):
n = int(input())
ls = get_ls()
ans = 0
for i in range(n - 1):
for j in range(i + 1, n):
if ls[i] >= ls[j]:
ans += 1
print(ans)
main() | IMPORT FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR FUNC_DEF FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | t = int(input())
out = ""
for _ in range(t):
n = int(input())
arr = [int(x) for x in input().split()]
passed = []
ans = 0
for x in arr:
i = 0
for i in range(len(passed)):
if passed[i] >= x:
break
else:
i += 1
ans += len(passed) - i
if i > len(passed):
ans += 1
passed.append(x)
else:
passed.insert(i, x)
out += str(ans) + "\n"
print(out) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR VAR IF VAR FUNC_CALL VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR BIN_OP FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | for p in range(int(input())):
n = int(input())
r = 0
a = list(map(int, input().split()))
for i in range(len(a)):
for j in range(i):
if a[j] >= a[i]:
r += 1
print(r) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
cnt = 0
for i, j in enumerate(a):
cnt += sum([(1) for v in a[i + 1 :] if v <= j])
print(cnt) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR NUMBER VAR VAR BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | class Solution:
def solve(self, a, n):
if len(a) == 1:
return 0
count = 0
for i in range(n - 1):
for j in range(i + 1, n):
if a[i] >= a[j]:
count += 1
return count
T = int(input())
while T:
T -= 1
n = int(input())
a = list(map(int, input().split()))
result = Solution().solve(a, n)
print(result) | CLASS_DEF FUNC_DEF IF FUNC_CALL VAR VAR NUMBER RETURN NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | t = int(input())
while t > 0:
n = int(input())
numbers = [int(num) for num in input().split(" ", n - 1)]
sum = 0
for i in range(1, len(numbers)):
for j in range(i):
if numbers[i] <= numbers[j]:
sum = sum + 1
print(sum)
t = t - 1 | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR STRING BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | def solve():
terminal_size = int(input())
connections = list(map(int, input().split(" ")))
rtn = 0
for i in range(len(connections)):
for j in range(i + 1, len(connections)):
if connections[j] <= connections[i]:
rtn += 1
print(rtn)
for _ in range(int(input())):
solve() | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | t = int(input())
while t:
n = int(input())
arr = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i + 1, n):
if arr[i] >= arr[j]:
ans += 1
print(ans)
t -= 1 | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR NUMBER |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | t = int(input())
out = ""
for _ in range(t):
n = int(input())
a = [(int(x) - 1) for x in input().split()]
count = [0] * n
ans = 0
for x in a:
ans += count[x]
for i in range(x + 1):
count[i] += 1
out += str(ans) + "\n"
print(out) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP FUNC_CALL VAR VAR NUMBER VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR ASSIGN VAR NUMBER FOR VAR VAR VAR VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR STRING EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i + 1, n):
f1, t1 = i + 1, a[i]
f2, t2 = j + 1, a[j]
if f1 > f2:
if t1 <= t2:
ans += 1
elif t2 <= t1:
ans += 1
print(ans) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR ASSIGN VAR VAR BIN_OP VAR NUMBER VAR VAR ASSIGN VAR VAR BIN_OP VAR NUMBER VAR VAR IF VAR VAR IF VAR VAR VAR NUMBER IF VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | def solution(content, n):
a = list(zip(range(1, n + 1), content))
a.sort(key=lambda x: (x[1], -x[0]))
result = 0
for i, (source, dest) in enumerate(a):
j = i - 1
while j >= 0:
s, d = a[j]
if s > source or d == dest:
result += 1
j -= 1
print(result)
t = int(input())
for i in range(t):
n = int(input())
content = [int(i) for i in input().split()]
solution(content, n) | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR EXPR FUNC_CALL VAR VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR NUMBER ASSIGN VAR VAR VAR VAR IF VAR VAR VAR VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | for t in range(int(input())):
n = int(input())
ans = list(map(int, input().split(" ")))
result = [(0) for _ in range(n)]
result[0] = 0
for i in range(1, n):
for j in range(i):
if ans[j] >= ans[i]:
result[i] += 1
print(sum(result)) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | t = int(input())
for nabor in range(t):
n = int(input())
arr = tuple(map(int, input().split()))
counts = {}
count = 0
for i in arr:
for k, v in counts.items():
if k >= i:
count += v
try:
counts[i] += 1
except KeyError:
counts[i] = 1
print(count) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT ASSIGN VAR NUMBER FOR VAR VAR FOR VAR VAR FUNC_CALL VAR IF VAR VAR VAR VAR VAR VAR NUMBER VAR ASSIGN VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
p = 0
for j in range(i):
if a[j] >= a[i]:
p += 1
ans += p
print(ans) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR NUMBER VAR VAR EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | def getsum(BITTree, i):
s = 0
i = i + 1
while i > 0:
s += BITTree[i]
i -= i & -i
return s
def updatebit(BITTree, n, i, v):
i += 1
while i <= n:
BITTree[i] += v
i += i & -i
def construct(arr, n):
BITTree = [0] * (n + 1)
for i in range(n):
updatebit(BITTree, n, i, arr[i])
return BITTree
for _ in range(int(input())):
n = int(input())
arr = [int(x) for x in input().split()]
ar = [0] * (n + 2)
tree = construct(ar, n + 1)
ans = 0
for i in range(n):
above = i + 1
below = arr[i]
ans += i - getsum(tree, below - 1)
updatebit(tree, n + 1, below, 1)
print(ans) | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR NUMBER VAR VAR VAR VAR BIN_OP VAR VAR RETURN VAR FUNC_DEF VAR NUMBER WHILE VAR VAR VAR VAR VAR VAR BIN_OP VAR VAR FUNC_DEF ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR VAR VAR RETURN VAR FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER BIN_OP VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR VAR BIN_OP VAR FUNC_CALL VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | cases = int(input())
c = []
for i in range(cases):
n = int(input())
c.append(list(map(int, input().strip().split())))
pairs = []
Dict = {}
for i in c:
for j in range(1, len(i) + 1):
Dict[j] = i[j - 1]
pairs.append(Dict)
Dict = {}
for d in pairs:
count = 0
for i in range(1, len(list(d.keys())) + 1):
for j in range(i + 1, len(list(d.keys())) + 1):
if d[j] <= d[i]:
count += 1
print(count) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR LIST FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR DICT FOR VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR VAR NUMBER ASSIGN VAR VAR VAR BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR ASSIGN VAR DICT FOR VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | t = int(input())
for _ in range(t):
n = int(input())
lst = [0] + list(map(int, input().split(" ")))
x = 0
for i in range(1, n + 1):
for j in range(i + 1, n + 1):
if lst[i] >= lst[j]:
x += 1
print(x) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | def main():
t = int(input())
for k in range(t):
n = int(input())
read = list(map(int, input().strip().split()))[:n]
ans = 0
for i in range(n):
for j in range(i + 1, n):
if read[i] >= read[j]:
ans += 1
print(ans)
main() | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | def fun(n, l):
res = 0
j = 0
for i in range(1, n):
k = i
while l[i] <= l[j] and j >= 0:
l[j], l[i] = l[i], l[j]
i, j = j, j - 1
res += 1
j = k
return res
N = int(input())
for i in range(N):
n = int(input())
l = list(map(int, input().split()))
print(fun(n, l)) | FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR ASSIGN VAR VAR WHILE VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR VAR RETURN VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | cases = int(input())
while cases:
count = 0
cases -= 1
n = int(input())
arr = list(map(int, input().split()))
i = 0
while i < len(arr):
j = i + 1
while j < len(arr):
if arr[i] >= arr[j]:
count += 1
j += 1
i += 1
print(count) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR ASSIGN VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER WHILE VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER WHILE VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR NUMBER VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | import sys
input = sys.stdin.readline
def inp():
return int(input())
def inlt():
return list(map(int, input().split()))
def insr():
s = input()
return list(s[: len(s) - 1])
def invr():
return map(int, input().split())
def foo(n, arr):
cross = 0
if n <= 1:
return 0
mid = n // 2
l = arr[:mid]
r = arr[mid:]
cross += foo(len(l), l) + foo(len(r), r)
i = j = k = 0
while i < len(l) and j < len(r):
if l[i] < r[j]:
arr[k] = l[i]
i += 1
else:
arr[k] = r[j]
j += 1
cross += len(l) - i
k += 1
while i < len(l):
arr[k] = l[i]
i += 1
k += 1
while j < len(r):
arr[k] = r[j]
j += 1
k += 1
return cross
num = inp()
for i in range(num):
line1 = inp()
line2 = inlt()
print(foo(line1, line2)) | IMPORT ASSIGN VAR VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR FUNC_DEF RETURN FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR FUNC_CALL VAR RETURN FUNC_CALL VAR VAR BIN_OP FUNC_CALL VAR VAR NUMBER FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER IF VAR NUMBER RETURN NUMBER ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR ASSIGN VAR VAR VAR VAR BIN_OP FUNC_CALL VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR VAR ASSIGN VAR VAR VAR NUMBER WHILE VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR IF VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR VAR NUMBER ASSIGN VAR VAR VAR VAR VAR NUMBER VAR BIN_OP FUNC_CALL VAR VAR VAR VAR NUMBER WHILE VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR NUMBER VAR NUMBER WHILE VAR FUNC_CALL VAR VAR ASSIGN VAR VAR VAR VAR VAR NUMBER VAR NUMBER RETURN VAR ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR EXPR FUNC_CALL VAR FUNC_CALL VAR VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | for case in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
res = 0
for i in range(n):
top = i + 1
bot = arr[i]
for j in range(n):
if i == j:
continue
tempTop = j + 1
tempBot = arr[j]
if tempTop <= top and tempBot >= bot:
res += 1
continue
if tempTop >= top and tempBot <= bot:
res += 1
continue
print(res // 2) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR FOR VAR FUNC_CALL VAR VAR IF VAR VAR ASSIGN VAR BIN_OP VAR NUMBER ASSIGN VAR VAR VAR IF VAR VAR VAR VAR VAR NUMBER IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | N = int(input())
for _ in range(N):
n = int(input())
a = map(int, input().split())
c = list(zip(range(1, n + 1), a))
res = 0
for i in range(n - 1):
for j in range(i + 1, n):
if c[j][1] <= c[i][1]:
res += 1
print(res) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR NUMBER VAR VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR |
The only difference between the two versions is that in this version $n \leq 1000$ and the sum of $n$ over all test cases does not exceed $1000$.
A terminal is a row of $n$ equal segments numbered $1$ to $n$ in order. There are two terminals, one above the other.
You are given an array $a$ of length $n$. For all $i = 1, 2, \dots, n$, there should be a straight wire from some point on segment $i$ of the top terminal to some point on segment $a_i$ of the bottom terminal. You can't select the endpoints of a segment. For example, the following pictures show two possible wirings if $n=7$ and $a=[4,1,4,6,7,7,5]$.
A crossing occurs when two wires share a point in common. In the picture above, crossings are circled in red.
What is the maximum number of crossings there can be if you place the wires optimally?
-----Input-----
The first line contains an integer $t$ ($1 \leq t \leq 1000$) — the number of test cases.
The first line of each test case contains an integer $n$ ($1 \leq n \leq 1000$) — the length of the array.
The second line of each test case contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \leq a_i \leq n$) — the elements of the array.
The sum of $n$ across all test cases does not exceed $1000$.
-----Output-----
For each test case, output a single integer — the maximum number of crossings there can be if you place the wires optimally.
-----Examples-----
Input
4
7
4 1 4 6 7 7 5
2
2 1
1
1
3
2 2 2
Output
6
1
0
3
-----Note-----
The first test case is shown in the second picture in the statement.
In the second test case, the only wiring possible has the two wires cross, so the answer is $1$.
In the third test case, the only wiring possible has one wire, so the answer is $0$. | import sys
sys.setrecursionlimit(10**6)
class TreeNode:
def __init__(self, val, col):
self.val = val
self.col = col
self.ch = []
def inord(self):
print(self.val)
for c in self.ch:
c.inord()
def balcnt(root):
if root == None:
return [0, 0]
allw = 0
allb = 0
for c in root.ch:
w, b = balcnt(c)
allw += w
allb += b
if root.col == 0:
allw += 1
else:
allb += 1
if allw == allb:
cnt[0] += 1
return [allw, allb]
t = int(input())
for tc in range(t):
n = int(input())
a = list(map(int, input().split()))
cnt = 0
for i in range(len(a)):
for j in range(i + 1, len(a)):
if a[j] <= a[i]:
cnt += 1
print(cnt) | IMPORT EXPR FUNC_CALL VAR BIN_OP NUMBER NUMBER CLASS_DEF FUNC_DEF ASSIGN VAR VAR ASSIGN VAR VAR ASSIGN VAR LIST FUNC_DEF EXPR FUNC_CALL VAR VAR FOR VAR VAR EXPR FUNC_CALL VAR FUNC_DEF IF VAR NONE RETURN LIST NUMBER NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR IF VAR NUMBER VAR NUMBER VAR NUMBER IF VAR VAR VAR NUMBER NUMBER RETURN LIST VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR IF VAR VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
while t:
t -= 1
n, k = input().split()
n = int(n)
k = int(k)
count = 0
for i in range(n - 1):
over = False
for j in range(i + 1, n):
if count < 2 * n + k:
print(i + 1, j + 1)
count += 1
else:
over = True
break
if over:
break | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR VAR NUMBER ASSIGN VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR FUNC_CALL VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR BIN_OP BIN_OP NUMBER VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR NUMBER IF VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
for _ in range(t):
n, p = [int(x) for x in input().split()]
p += 2 * n
for i in range(1, n):
if p == 0:
break
for j in range(i + 1, n + 1):
if p == 0:
break
else:
p -= 1
print(f"{i} {j}") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR VAR BIN_OP NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER VAR IF VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER EXPR FUNC_CALL VAR VAR STRING VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
for ignored in range(t):
n, p = list(map(int, input().split()))
a = [([False] * n) for i in range(n)]
cnt = [0] * n
for i in range(2 * n + p):
mini = float("inf")
minim = float("inf")
x, y = -1, -1
for x1 in range(n):
for y1 in range(x1 + 1, n):
if (
x1 != y1
and not a[x1][y1]
and (
max(cnt[x1], cnt[y1]) < mini
or max(cnt[x1], cnt[y1]) == mini
and min(cnt[x1], cnt[y1]) < minim
)
):
x, y = x1, y1
mini = max(cnt[x1], cnt[y1])
minim = min(cnt[x1], cnt[y1])
cnt[x] += 1
cnt[y] += 1
a[x][y] = True
a[y][x] = True
print(x + 1, y + 1) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP LIST NUMBER VAR VAR FUNC_CALL VAR VAR ASSIGN VAR BIN_OP LIST NUMBER VAR FOR VAR FUNC_CALL VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR FUNC_CALL VAR STRING ASSIGN VAR VAR NUMBER NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR FUNC_CALL VAR VAR VAR VAR VAR VAR ASSIGN VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR ASSIGN VAR FUNC_CALL VAR VAR VAR VAR VAR VAR VAR NUMBER VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER ASSIGN VAR VAR VAR NUMBER EXPR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | for _ in range(int(input())):
v, p = [int(x) for x in input().split()]
counter1 = 1
counter2 = 1
counter3 = 0
while counter3 != 2 * v + p:
counter3 += 1
print(counter1, counter2 + counter1)
counter2 += 1
if counter2 + counter1 == v + 1:
counter2 = 1
counter1 += 1 | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP BIN_OP NUMBER VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP VAR VAR VAR NUMBER IF BIN_OP VAR VAR BIN_OP VAR NUMBER ASSIGN VAR NUMBER VAR NUMBER |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | from sys import stdin
def main():
t = int(stdin.readline())
for _ in range(t):
n, p = map(int, stdin.readline().split())
for i in range(n):
print(i + 1, (i + 1) % n + 1)
count = n + p
ok = False
for i in range(n):
for j in range(i + 1, n):
if (i - 1) % n != j and (i + 1) % n != j:
print(i + 1, j + 1)
count -= 1
if count == 0:
ok = True
break
if ok:
break
main() | FUNC_DEF ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER ASSIGN VAR BIN_OP VAR VAR ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER VAR IF BIN_OP BIN_OP VAR NUMBER VAR VAR BIN_OP BIN_OP VAR NUMBER VAR VAR EXPR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR NUMBER IF VAR NUMBER ASSIGN VAR NUMBER IF VAR EXPR FUNC_CALL VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | for _ in range(int(input())):
n, p = map(int, input().split())
num = 0
k = True
for i in range(1, n + 1):
if k:
for j in range(i + 1, n + 1):
num += 1
if num == 2 * n + p:
k = False
print(i, j)
break
print(i, j) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER VAR NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
for test in range(t):
n, p = map(int, input().split())
s = ""
for i in range(n):
s += str(i + 1) + " " + str((i + 1) % n + 1) + "\n"
s += str(i + 1) + " " + str((i + 2) % n + 1) + "\n"
if p > 0:
for i in range(n):
for j in range(i + 3, min(n, i - 2 + n)):
s += str(i + 1) + " " + str(j + 1) + "\n"
p -= 1
if p <= 0:
break
if p <= 0:
break
print(s, end="") | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR STRING FOR VAR FUNC_CALL VAR VAR VAR BIN_OP BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER STRING FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER STRING VAR BIN_OP BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER STRING FUNC_CALL VAR BIN_OP BIN_OP BIN_OP VAR NUMBER VAR NUMBER STRING IF VAR NUMBER FOR VAR FUNC_CALL VAR VAR FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER FUNC_CALL VAR VAR BIN_OP BIN_OP VAR NUMBER VAR VAR BIN_OP BIN_OP BIN_OP FUNC_CALL VAR BIN_OP VAR NUMBER STRING FUNC_CALL VAR BIN_OP VAR NUMBER STRING VAR NUMBER IF VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR VAR STRING |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
for _ in range(t):
n, p = map(int, input().split())
for i in range(2 * n + p):
print(i % n + 1, (i + i // n + 1) % n + 1) | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR BIN_OP BIN_OP NUMBER VAR VAR EXPR FUNC_CALL VAR BIN_OP BIN_OP VAR VAR NUMBER BIN_OP BIN_OP BIN_OP BIN_OP VAR BIN_OP VAR VAR NUMBER VAR NUMBER |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | import sys
def get_ints():
return map(int, sys.stdin.readline().strip().split())
t = int(input())
while t:
flag = 0
n, p = get_ints()
count = 0
i = 1
while i < n + 1:
for j in range(i + 1, n + 1):
print(i, j)
count += 1
if count == 2 * n + p:
flag = 1
break
if flag == 1:
break
i += 1
t -= 1 | IMPORT FUNC_DEF RETURN FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL FUNC_CALL VAR ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR WHILE VAR ASSIGN VAR NUMBER ASSIGN VAR VAR FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR NUMBER IF VAR NUMBER VAR NUMBER VAR NUMBER |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
for tt in range(t):
n, p = map(int, input().split(" "))
edge_count = 0
edge_len = 1
v = 0
while edge_count < 2 * n + p:
print("{} {}".format(v + 1, (v + edge_len) % n + 1))
v = (v + 1) % n
edge_count += 1
if edge_count % n == 0:
edge_len += 1 | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR STRING ASSIGN VAR NUMBER ASSIGN VAR NUMBER ASSIGN VAR NUMBER WHILE VAR BIN_OP BIN_OP NUMBER VAR VAR EXPR FUNC_CALL VAR FUNC_CALL STRING BIN_OP VAR NUMBER BIN_OP BIN_OP BIN_OP VAR VAR VAR NUMBER ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR VAR NUMBER IF BIN_OP VAR VAR NUMBER VAR NUMBER |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
for i in range(t):
n, p = [int(j) for j in input().split()]
for x in range(1, n + 1):
for y in range(x + 1, n + 1):
if min(y - x, x + n - y) <= 2:
print(x, y)
elif p > 0:
print(x, y)
p -= 1 | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF FUNC_CALL VAR BIN_OP VAR VAR BIN_OP BIN_OP VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR IF VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR NUMBER |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
for _ in range(t):
n, p = map(int, input().split())
k = 2 * n + p
pre = 1
while k > 0:
for i in range(pre + 1, n + 1):
print(pre, i)
k = k - 1
if k == 0:
break
pre += 1 | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR NUMBER WHILE VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR VAR ASSIGN VAR BIN_OP VAR NUMBER IF VAR NUMBER VAR NUMBER |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | for _ in range(int(input())):
n, p = map(int, input().split())
d = {}
ans = 0
for i in range(1, n + 1):
d[i] = []
for i in range(1, n + 1):
for j in range(1, n + 1):
if len(d[i]) == 2 * n + p:
break
if j != i and j not in d[i]:
print(i, j)
ans += 1
d[i].append(j)
d[j].append(i)
if ans == 2 * n + p:
break
if ans == 2 * n + p:
break | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR DICT ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR LIST FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF FUNC_CALL VAR VAR VAR BIN_OP BIN_OP NUMBER VAR VAR IF VAR VAR VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR NUMBER EXPR FUNC_CALL VAR VAR VAR EXPR FUNC_CALL VAR VAR VAR IF VAR BIN_OP BIN_OP NUMBER VAR VAR IF VAR BIN_OP BIN_OP NUMBER VAR VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | for j in range(int(input())):
n, p = map(int, input().split())
k = (
[(str(i) + " " + str(i + 1)) for i in range(1, n)]
+ ["1 " + str(n), "1 " + str(n - 1), "2 " + str(n)]
+ [(str(i) + " " + str(i + 2)) for i in range(1, n - 1)]
)
for i in range(1, n - 2):
if p == 0:
break
for j in range(i + 3, n + int(i > 1) - (i < 3)):
k += [str(i) + " " + str(j)]
p -= 1
if p == 0:
break
print("\n".join(sorted(k))) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP BIN_OP BIN_OP FUNC_CALL VAR VAR STRING FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR NUMBER VAR LIST BIN_OP STRING FUNC_CALL VAR VAR BIN_OP STRING FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP STRING FUNC_CALL VAR VAR BIN_OP BIN_OP FUNC_CALL VAR VAR STRING FUNC_CALL VAR BIN_OP VAR NUMBER VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP BIN_OP VAR FUNC_CALL VAR VAR NUMBER VAR NUMBER VAR LIST BIN_OP BIN_OP FUNC_CALL VAR VAR STRING FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR FUNC_CALL STRING FUNC_CALL VAR VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | for t in range(int(input())):
n, p = map(int, input().split())
ans = []
cnt = 2 * n + p
for i in range(1, n + 1):
for j in range(i + 1, n + 1):
ans.append([i, j])
cnt -= 1
if cnt == 0:
break
if cnt == 0:
break
for i in ans:
print(*i) | FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR LIST ASSIGN VAR BIN_OP BIN_OP NUMBER VAR VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR LIST VAR VAR VAR NUMBER IF VAR NUMBER IF VAR NUMBER FOR VAR VAR EXPR FUNC_CALL VAR VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | t = int(input())
for i in range(t):
a, b = map(int, input().split())
c = a * 2 + b
for i in range(1, a + 1):
for j in range(i + 1, a + 1):
if c == 0:
break
print(str(i) + " " + str(j))
c -= 1
if c == 0:
break | ASSIGN VAR FUNC_CALL VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR BIN_OP BIN_OP VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF VAR NUMBER EXPR FUNC_CALL VAR BIN_OP BIN_OP FUNC_CALL VAR VAR STRING FUNC_CALL VAR VAR VAR NUMBER IF VAR NUMBER |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | import sys
input = lambda: sys.stdin.readline().strip()
def solve(n, p):
total = 0
used = set()
for d in range(1, n):
for i in range(1, n + 1):
u, v = i, (i + d - 1) % n + 1
e = min(u, v), max(u, v)
if e not in used:
used.add(e)
print(u, v)
total += 1
if total == 2 * n + p:
return
for _ in range(int(input())):
n, p = [int(x) for x in input().split()]
solve(n, p) | IMPORT ASSIGN VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER ASSIGN VAR FUNC_CALL VAR FOR VAR FUNC_CALL VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER ASSIGN VAR VAR VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER ASSIGN VAR FUNC_CALL VAR VAR VAR FUNC_CALL VAR VAR VAR IF VAR VAR EXPR FUNC_CALL VAR VAR EXPR FUNC_CALL VAR VAR VAR VAR NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR VAR RETURN FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | import sys
input = lambda: sys.stdin.readline().strip()
def solve(n, p):
total = 0
for d in range(1, n):
for i in range(1, n + 1):
print(i, (i + d - 1) % n + 1)
total += 1
if total == 2 * n + p:
return
for _ in range(int(input())):
n, p = [int(x) for x in input().split()]
solve(n, p) | IMPORT ASSIGN VAR FUNC_CALL FUNC_CALL VAR FUNC_DEF ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER VAR FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER EXPR FUNC_CALL VAR VAR BIN_OP BIN_OP BIN_OP BIN_OP VAR VAR NUMBER VAR NUMBER VAR NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR VAR RETURN FOR VAR FUNC_CALL VAR FUNC_CALL VAR FUNC_CALL VAR ASSIGN VAR VAR FUNC_CALL VAR VAR VAR FUNC_CALL FUNC_CALL VAR EXPR FUNC_CALL VAR VAR VAR |
Let's call an undirected graph of n vertices p-interesting, if the following conditions fulfill:
* the graph contains exactly 2n + p edges;
* the graph doesn't contain self-loops and multiple edges;
* for any integer k (1 ≤ k ≤ n), any subgraph consisting of k vertices contains at most 2k + p edges.
A subgraph of a graph is some set of the graph vertices and some set of the graph edges. At that, the set of edges must meet the condition: both ends of each edge from the set must belong to the chosen set of vertices.
Your task is to find a p-interesting graph consisting of n vertices.
Input
The first line contains a single integer t (1 ≤ t ≤ 5) — the number of tests in the input. Next t lines each contains two space-separated integers: n, p (5 ≤ n ≤ 24; p ≥ 0; <image>) — the number of vertices in the graph and the interest value for the appropriate test.
It is guaranteed that the required graph exists.
Output
For each of the t tests print 2n + p lines containing the description of the edges of a p-interesting graph: the i-th line must contain two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi) — two vertices, connected by an edge in the resulting graph. Consider the graph vertices numbered with integers from 1 to n.
Print the answers to the tests in the order the tests occur in the input. If there are multiple solutions, you can print any of them.
Examples
Input
1
6 0
Output
1 2
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6 | from sys import setrecursionlimit, stdin
t = int(stdin.readline().strip())
for _ in range(t):
n, p = list(map(int, stdin.readline().split()))
count = 0
flag = 0
for i in range(1, n + 1):
if flag == 1:
break
for j in range(i + 1, n + 1):
if count == 2 * n + p:
flag = 1
break
print(i, j)
count += 1 | ASSIGN VAR FUNC_CALL VAR FUNC_CALL FUNC_CALL VAR FOR VAR FUNC_CALL VAR VAR ASSIGN VAR VAR FUNC_CALL VAR FUNC_CALL VAR VAR FUNC_CALL FUNC_CALL VAR ASSIGN VAR NUMBER ASSIGN VAR NUMBER FOR VAR FUNC_CALL VAR NUMBER BIN_OP VAR NUMBER IF VAR NUMBER FOR VAR FUNC_CALL VAR BIN_OP VAR NUMBER BIN_OP VAR NUMBER IF VAR BIN_OP BIN_OP NUMBER VAR VAR ASSIGN VAR NUMBER EXPR FUNC_CALL VAR VAR VAR VAR NUMBER |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.