Challenges

Reddit challenges in python language.

Files Code and Result

challenge1_easy

challenge2_easy

challenge3_easy

challenge4_easy

challenge5_easy

challenge6_easy

challenge7_easy

challenge8_easy

challenge9_easy

challenge10_easy

challenge11.easy

challenge12_easy

challenge13_easy

challenge14_easy

challenge15_easy

challenge16_easy

challenge17_easy

challenge18_easy

challenge19_easy

challenge20_easy

challenge21_easy

challenge22_easy

challenge23_easy

challenge25_easy

challenge26_easy

challenge27_easy

challenge28_easy

challenge29_easy

challenge30_easy

challenge31_easy

challenge32_easy

challenge33_easy

challenge34_easy

challenge35_easy

challenge36_easy

challenge37_easy

challenge38_easy

challenge39_easy

challenge40_easy

challenge41_easy

challenge42_easy

challenge44_easy

challenge45_easy

challenge46_easy

challenge47_easy

challenge48_easy

challenge49_easy

challenge50_easy

challenge51_easy

challenge52_easy

challenge53_easy

challenge54_easy

challenge55_easy

challenge56_easy

challenge57_easy

challenge58_easy

challenge59_easy

challenge60_easy

challenge61_easy

challenge62_easy

challenge63_easy

challenge64_easy

challenge65_easy

challenge66_Dev

challenge66_easy

challenge67_easy

challenge68_easy

challenge69_easy

challenge69_easyBonus

challenge70_easy

challenge71_easy.py

challenge72_easy

challenge73_easy

challenge74_easy

challenge76_easy

challenge77_easy

challenge78_easy

challenge79_easy

challenge80_easyone

challenge82_easy

challenge83_easy

challenge84_easy

challenge85_easy

challenge85_easybonus

challenge86_easy

challenge87_easy

challenge88_easy

challenge88_easybonus

challenge89_easy

challenge90_easy

challenge91_easy

challenge92_easy

challenge93_easy

challenge94_easy

challenge95_easy

challenge96_easy

challenge97_easy

challenge98_easy

challenge99_easy

challenge100_easy

challenge100_easybonus

challenge101_easy

challenge101_easybonus

challenge102_easy

challenge103_easy

challenge104_easy

challenge105_easy

challenge106_easy

challenge107_easy

challenge108_easy

challenge109_easy

challenge110_easy

challenge111_easy2

challenge112_easy

challenge113_easy

challenge114_easy

challenge115_easy

challenge116_easy

challenge117_easy

challenge118_easy

challenge119_easy

challenge121_easy

challenge122_easy

challenge123_easy

challenge124_easy

challenge125_easy

challenge126_easy

challenge127_easy

challenge128_easy

challenge130_easy

challenge131_east

challenge132_easy

challenge133_easy

challenge134_easy

challenge135_easy

challenge136_easy

challenge137_easy

challenge138_easy

challenge139_easy

challenge140_easy

challenge141_easy

challenge142_easy

challenge143_easy

challenge144_easy

challenge145_easy

challenge146_easy

challenge147_easy

challenge148_easy

challenge149_easy

challenge153_easy

challenge153_easy

challenge154_easy

challenge156_easy

challenge157_easy

challenge158_easy

challenge158_easybonus

challenge159_easy

challenge160_easy

challenge161_easy

challenge162_easy

challenge163__easy

challenge168_easy

challenge169_easy

challenge169_easybonus

challenge170_easy

challenge171_easy

challenge172_easy

challenge174_easy

challenge175_easy

challenge177_easy

challenge179_easy

challenge180_easy

challenge181_easy

challenge182_easy

challenge184_easy

challenge185_easy

challenge188_easy

challenge189_easy_ascii

challenge191_easy

challenge192_easy

challenge193_easy

challenge195_easy

challenge197_easy

challenge198_easy

challenge199_easy

challenge200_easy

challenge201_easy

challenge202_easy

challenge203_easy

challenge204_easy

challenge204_easyBonus

challenge205_easy

challenge205_easyBonu

challenge206_easy

challenge207_easy

challenge208_easy

challenge210_easy

challenge211_easy

challenge212_easy

challenge212_easybonus

challenge213_easy

challenge214_easy

challenge215_easy

challenge216_easy

challenge217_easy

challenge218_easy

challenge218_easyBonus1

challenge218_easyBunus2

challenge219_easy

challenge220_easy.py

challenge221_easy

challenge221_easy

challenge222_easy

challenge222_easy.py

challenge223_easy

challenge226_easy

challenge226_easy

challenge228_easy.py

challenge228_easydev

challenge229_easy

challenge229_easybonus.py

challenge231_easy

challenge232_easy

challenge232_easy

challenge232_easybonus

challenge234_easy

challenge234_easybonus

challenge235_easy

challenge236_easy

challenge237_easy

challenge238_easy

challenge238_easybonus

challenge239_easy

challenge240_easy

challenge242_easy

challenge242_easy

challenge242_easyBonus

challenge243_easy

challenge245_easy

challenge245_easyBonus

challenge246_easy

challenge247_easy

challenge249_easy

challenge251_easy

challenge251_easy

challenge251_easybonus

challenge252_easy

challenge252_easy

challenge253_easy

challenge254_easy

challenge255_easy

challenge257_easy

challenge261_easy

challenge267_easy

challenge269_easy

challenge270_easy

challenge272_easy

challenge277_easy

challenge282_easy

challenge282_easy_bonus

challenge283_easy

challenge284_easy

challenge286_easy

challenge287_easy

challenge288_easy

challenge290_easy

challenge290_easybonus

challenge291_easy

challenge291_easybonus

challenge302_easy

challenge308_easy

challenge311_easy

challenge313_easy

challenge313_easy

challenge314_easy

challenge315_easy

challenge319_easy

challenge323_easy

challenge324_easy

challenge325_easy

challenge328_easy

challenge330_easy

challenge330_easybonus

challenge335_easy

challenge338_easy

challenge340_easy

challenge341_easy

challenge342_easy

challenge344_easy

challenge325_easy

def path_check(maze, x, y, code_num,):
    '''Check if there is a null route
    by running a further move, no
    cache collection would be the
    result.'''
    cache = []
    code_num += 1
    code_index = code_num % 5
    target = code_list[code_index]
    up = step_up(maze1, x, y)
    if up[0] == target:
        cache.append((x, y - 1))
    down = step_down(maze1, x, y)
    if down[0] == target:
        cache.append((x, y + 1))
    left = walk_left(maze1, x, y)
    if left[0] == target:
        cache.append((x - 1, y))
    right = walk_right(maze1, x, y)
    if right[0] == target:
        cache.append((x + 1, y))
    if len(cache) == 0:
        return False
    else:
        return True


def walk_left(maze, x, y):
    if x - 1 == -1:
        return ' '
    ans = maze[y][x - 1]
    return ans, y, x - 1


def walk_right(maze, x, y):
    if x + 1 == -1 or x > len(maze1):
        return ' '
    ans = maze[y][x + 1]
    return ans, y, x + 1


def step_up(maze, x, y):
    if y - 1 == -1:
        return ' '
    ans = maze[y - 1][x]
    return ans, y - 1, x


def step_down(maze, x, y):
    if y + 1 == -1:
        return ' '
    ans = maze[y + 1][x]
    return ans, y + 1, x



if __name__ == '__main__':

    candidates = '''R R B R R R B P Y G P B B B G P B P P R
    B G Y P R P Y Y O R Y P P Y Y R R R P P
    B P G R O P Y G R Y Y G P O R Y P B O O
    R B B O R P Y O O Y R P B R G R B G P G
    R P Y G G G P Y P Y O G B O R Y P B Y O
    O R B G B Y B P G R P Y R O G Y G Y R P
    B G O O O G B B R O Y Y Y Y P B Y Y G G
    P P G B O P Y G B R O G B G R O Y R B R
    Y Y P P R B Y B P O O G P Y R P P Y R Y
    P O O B B B G O Y G O P B G Y R R Y R B
    P P Y R B O O R O R Y B G B G O O P B Y
    B B R G Y G P Y G P R R P Y G O O Y R R
    O G R Y B P Y O P B R Y B G P G O O B P
    R Y G P G G O R Y O O G R G P P Y P B G
    P Y P R O O R O Y R P O R Y P Y B B Y R
    O Y P G R P R G P O B B R B O B Y Y B P
    B Y Y P O Y O Y O R B R G G Y G R G Y G
    Y B Y Y G B R R O B O P P O B O R R R P
    P O O O P Y G G Y P O G P O B G P R P B
    R B B R R R R B B B Y O B G P G G O O Y'''



    # prepare the maze
    maze1 = []
    maze = candidates.splitlines()
    for line in maze:
        line = line.replace(' ', '')
        line = line.strip()
        maze1.append(line)


    cache = []
    code_list = ['R', 'O', 'Y', 'P', 'O']
    code_num = 0
    code_index = code_num%5
    target = code_list[code_index]
    n = len(maze1)
    path = []
    candidate_list = {}

    # starting move, initial 'R'
    for y in range(n - 1, -1, -1):
        for x in range(0, n):
            if y == n - 1:
                # initial target and co-ords
                temp = maze1[y][x]
                if temp == target:
                    # if this is the target, add it to the path.
                    path.append((x, y, target))
                    # code number advances to give next target, 'O'
                    code_num += 1
                    code_index = code_num % 5
                    target = code_list[code_index]
                    # go up looking for the target
                    up = step_up(maze1, x, y)
                    # add to cache
                    cache.append((x,y - 1))
                    # if not the target continue to next x
                    if not up[0] == target:
                        code_num -= 1
                        code_index = code_num % 5
                        target = code_list[code_index]
                        path = []
                        cache = []
                        continue
                    else:
                        # if target correct
                        path.append((cache[0], target))
                        x = cache[0][0]
                        y = cache[0][1]
                        # reset cache
                        cache = []
                        while True:
                            code_num += 1
                            code_index = code_num % 5
                            target = code_list[code_index]
                            up = step_up(maze1, x, y)
                            if up[0] == target:
                                cache.append((x,y - 1))
                            down = step_down(maze1, x, y)
                            if down[0] == target:
                                cache.append((x,y + 1))
                            left = walk_left(maze1, x, y)
                            if left[0] == target:
                                cache.append((x - 1, y))
                            right = walk_right(maze1, x, y)
                            if right[0] == target:
                                cache.append((x + 1, y))
                            if len(cache) == 0 and y == 1:
                                print(path)
                                exit()
                            if len(cache) == 1:
                                path.append((cache[0], target))
                                x = cache[0][0]
                                y = cache[0][1]
                                cache = []
                            else:
                                x = cache[0][0]
                                y = cache[0][1]
                                if y >= cache[1][1]:
                                    x = cache[1][0]
                                    y = cache[1][1]
                                    cache = []
                                path_chk = path_check(maze1, x, y, code_num)
                                # note: test smallest 'Y' for shortest route
                                if path_chk:
                                    path.append((cache[0], target))
                                    x = cache[0][0]
                                    y = cache[0][1]
                                    cache = []
                                else:
                                    x = cache[1][0]
                                    y = cache[1][1]
                                    path.append((cache[1], target))
                                    cache = []
                                if y == 0:
                                    print(path)
                                    exit()

Result

[(3, 19, 'R'), ((3, 18), 'O'), ((3, 17), 'Y'), ((3, 16), 'P'), ((4, 16), 'O'), ((4, 15), 'R'), ((4, 16), 'O'), ((5, 16), 'Y'), ((5, 15), 'P'), ((5, 14), 'O'), ((6, 14), 'R'), ((6, 13), 'O'), ((6, 12), 'Y'), ((6, 11), 'P'), ((6, 10), 'O'), ((7, 10), 'R'), ((7, 9), 'O'), ((8, 9), 'Y'), ((8, 8), 'P'), ((9, 8), 'O'), ((9, 7), 'R'), ((9, 6), 'O'), ((10, 6), 'Y'), ((10, 5), 'P'), ((10, 4), 'O'), ((10, 3), 'R'), ((10, 4), 'O'), ((9, 4), 'Y'), ((8, 4), 'P'), ((8, 3), 'O'), ((8, 2), 'R'), ((8, 1), 'O'), ((8, 0), 'Y')]