There are N towers, each made of three single-colored blocks placed one on top of another. The colors of the towers' blocks are described in an array T made of N three-letter strings. String T[K] (for K within the range 0..N−1) describes the colors of the blocks from the bottom to the top of the K-th tower. Colors are represented by lowercase letters.
For each of the towers, we may − at most once − choose two adjacent blocks and swap them. For example, given T[K] = "abc", we may obtain "bac" by swapping the bottom two blocks or "acb" by swapping the top two blocks, or stick with "abc" by not making a swap at all. Our goal is to achieve the same order of colors (from the bottom to the top) in as many towers as possible.
What is the maximum number of towers with the same color order that we can obtain?
Write a function:
def solution(T)
that, given an array T consisting of N strings representing the towers' colors, returns the maximum number of towers that we can obtain with the same order of block colors.
Examples:
1. Given T = ["aab", "cab", "baa", "baa"], the function should return 3. We may create towers ["aba", "cab", "aba", "aba"] by swapping the top two blocks in tower number 0, the bottom two blocks in towers with numbers 2 and 3. This way, towers numbers 0, 2 and 3 will have the same order of colors.
2. Given T = ["zzz", "zbz", "zbz", "dgf"], the function should return 2. It is not necessary to perform any swaps to obtain the result.
3. Given T = ["abc", "cba", "cab", "bac", "bca"], the function should return 3.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..50,000];
- each string in array T consists only of lowercase letters (a−z);
- each string in array T is of length 3.
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[3]
set_of_orders = {order_a, order_b, order_c}
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[3]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[3]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(0)
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[3]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order)
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[3]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 1) + 1
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[3]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 1) + 1
to_return = 0
for key, value in dic_of_orders:
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[3]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 1) + 1
to_return = 0
for key, value in dic_of_orders:
to_return = to_return if to_return > value else value
return to_return
Traceback (most recent call last): File "exec.py", line 129, in <module> main() File "exec.py", line 91, in main result = solution( T ) File "/tmp/solution.py", line 10, in solution order_c = color_order[1] + color_order[0] + color_order[3] IndexError: string index out of range
Traceback (most recent call last): File "exec.py", line 129, in <module> main() File "exec.py", line 91, in main result = solution( T ) File "/tmp/solution.py", line 10, in solution order_c = color_order[1] + color_order[0] + color_order[3] IndexError: string index out of range
Traceback (most recent call last): File "exec.py", line 129, in <module> main() File "exec.py", line 91, in main result = solution( T ) File "/tmp/solution.py", line 10, in solution order_c = color_order[1] + color_order[0] + color_order[3] IndexError: string index out of range
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[2]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 1) + 1
to_return = 0
for key, value in dic_of_orders:
to_return = to_return if to_return > value else value
return to_return
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[2]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 1) + 1
to_return = 0
for key, value in dic_of_orders:
to_return = to_return if to_return > value else value
return to_return
Traceback (most recent call last): File "exec.py", line 129, in <module> main() File "exec.py", line 91, in main result = solution( T ) File "/tmp/solution.py", line 19, in solution for key, value in dic_of_orders: ValueError: too many values to unpack (expected 2)
Traceback (most recent call last): File "exec.py", line 129, in <module> main() File "exec.py", line 91, in main result = solution( T ) File "/tmp/solution.py", line 19, in solution for key, value in dic_of_orders: ValueError: too many values to unpack (expected 2)
Traceback (most recent call last): File "exec.py", line 129, in <module> main() File "exec.py", line 91, in main result = solution( T ) File "/tmp/solution.py", line 19, in solution for key, value in dic_of_orders: ValueError: too many values to unpack (expected 2)
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[2]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 1) + 1
to_return = 0
for key, value in dic_of_orders.:
to_return = to_return if to_return > value else value
return to_return
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[2]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 1) + 1
to_return = 0
for key, value in dic_of_orders.items():
to_return = to_return if to_return > value else value
return to_return
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[2]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 0) + 1
to_return = 0
for key, value in dic_of_orders.items():
to_return = to_return if to_return > value else value
return to_return
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[2]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 0) + 1
to_return = 0
for key, value in dic_of_orders.items():
to_return = to_return if to_return > value else value
return to_return
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(T):
dic_of_orders = {}
for color_order in T:
order_a = color_order
order_b = color_order[0] + color_order[2] + color_order[1]
order_c = color_order[1] + color_order[0] + color_order[2]
set_of_orders = {order_a, order_b, order_c}
for order in set_of_orders:
dic_of_orders[order] = dic_of_orders.get(order, 0) + 1
to_return = 0
for key, value in dic_of_orders.items():
to_return = to_return if to_return > value else value
return to_return
The solution obtained perfect score.