# Thoughts on Puzzle 12 - Arrow Maze?

**URL:** https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002
**Category:** General
**Tags:** open-discussion
**Created:** [July 7, 2022, 7:48pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002 "2022-07-07T19:48:21Z")
**Posts on this page:** 20
**Page:** 4

<div class="post-metadata">

### Author: ![just\_T3](https://avatars.discourse-cdn.com/v4/letter/j/ed655f/32.png) [@just\_T3](https://community.rapyd.net/u/just_T3)
#### Post date: [July 12, 2022, 7:35pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/64 "2022-07-12T19:35:07Z")

</div>

But if I shift each letter +1 on the row it could eventually move into the right way

---

<div class="post-metadata">

### Author: ![Sylthrim](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/sylthrim/32/8201_2.png) [@Sylthrim](https://community.rapyd.net/u/Sylthrim)
#### Post date: [July 12, 2022, 7:36pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/65 "2022-07-12T19:36:45Z")

</div>

Look at how all 6 words are organized. Ask yourself which one goes first, second, third etc. Maybe in order of the body.

---

<div class="post-metadata">

### Author: ![michalush](https://avatars.discourse-cdn.com/v4/letter/m/a9a28c/32.png) [@michalush](https://community.rapyd.net/u/michalush)
#### Post date: [July 12, 2022, 7:48pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/66 "2022-07-12T19:48:03Z")

</div>

Nice solutions everyone! It’s nice to learn such things.

---

<div class="post-metadata">

### Author: ![Noonian-Soong](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/noonian-soong/32/22676_2.png) [@Noonian-Soong](https://community.rapyd.net/u/Noonian-Soong)
#### Post date: [July 12, 2022, 10:22pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/67 "2022-07-12T22:22:40Z")

</div>

That is _waaay_ faster than mine. Awesome work!

---

<div class="post-metadata">

### Author: ![MusaddiqueAli](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/musaddiqueali/32/3309_2.png) [@MusaddiqueAli](https://community.rapyd.net/u/MusaddiqueAli)
#### Post date: [July 13, 2022, 12:57am UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/68 "2022-07-13T00:57:28Z")

</div>

😄 Now I realize that the bone hint was too big of a hint. I should have given a hint like it’s on the upper part of the body, something like that. But, anyways.

I personally took kind of a bruteforce approach to find the 3rd BODYPART. I had to use an online dictionary to find that word, a dictionary where I can search based on the length of the word, based on what letters it contains, what letters it begins with and what letters it ends with. And manually changing those variables again and again until I found the right one.

---

<div class="post-metadata">

### Author: ![galactic](https://avatars.discourse-cdn.com/v4/letter/g/7cd45c/32.png) [@galactic](https://community.rapyd.net/u/galactic)
#### Post date: [July 13, 2022, 7:14am UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/69 "2022-07-13T07:14:30Z")

</div>

Here’s my wordy JS solution with backtracking. It can be improved in many ways but as it stands, it takes less than a second to run on my pc. It was fun to revisit backtracking since it is not something I usually need.

```auto
const DIRECTION = {
  UP: 'up',
  UP_RIGHT: 'up_right',
  RIGHT: 'right',
  DOWN_RIGHT: 'down_right',
  DOWN: 'down',
  DOWN_LEFT: 'down_left',
  LEFT: 'left',
  UP_LEFT: 'up_left'
}

/**
 * 
 * @param {number | null} value 
 * @param {string} direction 
 * @param {number | null} order 
 */
function Cell(direction, value = null, order = null) {
  this.value = value
  this.direction = direction
  this.order = order
}

Cell.prototype.setCoords = function setCoords(x, y) {
  this.coords = { x, y }
}

/**
 * 
 * @param {Cell[][]} matrix 
 */
function ArrowMaze(matrix) {
  this.matrix = matrix
  this.values = this.matrix.flatMap(row => row.reduce(
    /**
     * 
     * @param {number[]} acc 
     * @param {Cell} cell 
     * @returns 
     */
    (acc, cell) => {
      if (cell.value) acc.push(cell.value)
      return acc
    }, []))
  this.matrix.forEach((row, y) => {
    row.forEach((cell, x) => {
      cell.setCoords(x, y)
    })
  })
}

/**
 * 
 * @param {string} direction 
 * @param {number} x 
 * @param {number} y 
 * @returns {{x: number, y: number}}
 */
ArrowMaze.prototype.getNextCoord = function getNextCoord(direction, x, y) {
  let nextX = x, nextY = y
  if ([DIRECTION.UP, DIRECTION.UP_LEFT, DIRECTION.UP_RIGHT].includes(direction)) nextY--
  if ([DIRECTION.DOWN, DIRECTION.DOWN_LEFT, DIRECTION.DOWN_RIGHT].includes(direction)) nextY++
  if ([DIRECTION.UP_RIGHT, DIRECTION.RIGHT, DIRECTION.DOWN_RIGHT].includes(direction)) nextX++
  if ([DIRECTION.UP_LEFT, DIRECTION.LEFT, DIRECTION.DOWN_LEFT].includes(direction)) nextX--
  return { x: nextX, y: nextY }
}

ArrowMaze.prototype.isValidCoord = function isValidCoord(x, y) {
  return x >= 0 && x < this.matrix[0].length && y >= 0 && y < this.matrix.length
}

/**
 * 
 * @param {Cell} cell 
 * @param {number} value
 */
ArrowMaze.prototype.isValidPlacement = function isValidPlacement(cell, value) {
  return cell.value === value || (cell.value === null && !this.values.includes(value))
}

/**
 * 
 * @param {Cell} cell 
 * @param {number} value 
 */
ArrowMaze.prototype.placeValue = function placeValue(cell, value) {
  cell.value = value
}

/**
 * 
 * @param {Cell} cell 
 */
ArrowMaze.prototype.undoValue = function undoValue(cell) {
  if (!this.values.includes(cell.value)) {
    cell.value = null
  }
}

function resetArrowMaze() {
  return new ArrowMaze([
    [new Cell(DIRECTION.DOWN_RIGHT, 1), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.DOWN_RIGHT), new Cell(DIRECTION.LEFT), new Cell(DIRECTION.LEFT), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.DOWN_LEFT)],
    [new Cell(DIRECTION.UP_RIGHT, null, 6), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.RIGHT), new Cell(DIRECTION.DOWN_RIGHT, 17), new Cell(DIRECTION.DOWN, 52), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.LEFT, null, 1)],
    [new Cell(DIRECTION.RIGHT), new Cell(DIRECTION.LEFT, 43), new Cell(DIRECTION.UP), new Cell(DIRECTION.DOWN_RIGHT, 14), new Cell(DIRECTION.DOWN_LEFT, null, 5), new Cell(DIRECTION.UP_RIGHT), new Cell(DIRECTION.DOWN, 10), new Cell(DIRECTION.LEFT, 45)],
    [new Cell(DIRECTION.DOWN), new Cell(DIRECTION.RIGHT), new Cell(DIRECTION.UP_RIGHT), new Cell(DIRECTION.UP_LEFT), new Cell(DIRECTION.UP_LEFT, 15), new Cell(DIRECTION.RIGHT, 28), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.LEFT)],
    [new Cell(DIRECTION.RIGHT, 60), new Cell(DIRECTION.LEFT), new Cell(DIRECTION.UP_LEFT, 26), new Cell(DIRECTION.RIGHT), new Cell(DIRECTION.DOWN_RIGHT), new Cell(DIRECTION.LEFT), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.LEFT, 61)],
    [new Cell(DIRECTION.DOWN), new Cell(DIRECTION.RIGHT, null, 2), new Cell(DIRECTION.DOWN), new Cell(DIRECTION.LEFT, 54), new Cell(DIRECTION.DOWN_RIGHT), new Cell(DIRECTION.RIGHT), new Cell(DIRECTION.UP_LEFT, null, 3), new Cell(DIRECTION.DOWN)],
    [new Cell(DIRECTION.UP_RIGHT), new Cell(DIRECTION.DOWN_RIGHT), new Cell(DIRECTION.RIGHT, 56), new Cell(DIRECTION.UP_RIGHT), new Cell(DIRECTION.UP_LEFT), new Cell(DIRECTION.LEFT), new Cell(DIRECTION.UP), new Cell(DIRECTION.UP)],
    [new Cell(DIRECTION.RIGHT), new Cell(DIRECTION.UP_LEFT), new Cell(DIRECTION.UP), new Cell(DIRECTION.LEFT, 33), new Cell(DIRECTION.RIGHT, null, 4), new Cell(DIRECTION.UP), new Cell(DIRECTION.LEFT), new Cell('', 64)],
  ])
}

function solveMaze() {
  const arrow_maze = resetArrowMaze()
  let currValue = 1
  let x = 0, y = 0
  const path = []
  let direction = ''
  do {
    if (arrow_maze.isValidCoord(x, y)) {
      const cell = arrow_maze.matrix[y][x]
      if (arrow_maze.isValidPlacement(cell, currValue)) {
        arrow_maze.placeValue(cell, currValue)
        currValue++
        direction = cell.direction
        path.push(cell)
      }
    } else {
      const last_cell = path.pop()
      const cell = path[path.length - 1]
      direction = cell.direction
      currValue = last_cell.value
      arrow_maze.undoValue(last_cell)
      x = last_cell.coords.x
      y = last_cell.coords.y
    }
    const coords = arrow_maze.getNextCoord(direction, x, y)
    x = coords.x
    y = coords.y
  } while (path.length < 64)
  printCode(arrow_maze)
  return path
}

/**
 * 
 * @param {ArrowMaze} solvedMaze 
 */
function printCode(solvedMaze) {
  const clues = solvedMaze.matrix.flat().filter(cell => cell.order !== null).sort((a, b) => a.order - b.order)
  const baseChar = 'A'.charCodeAt(0) - 1
  let code = ''
  clues.forEach(clue => {
    let charCode = clue.value
    if (clue.value > 52) charCode -= 52
    if (clue.value > 26) charCode -= 26
    code += String.fromCharCode(baseChar + charCode)
  })
  console.log('The answer is: ', code)
}

module.exports = solveMaze

```

---

<div class="post-metadata">

### Author: ![MusaddiqueAli](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/musaddiqueali/32/3309_2.png) [@MusaddiqueAli](https://community.rapyd.net/u/MusaddiqueAli)
#### Post date: [July 13, 2022, 8:51am UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/70 "2022-07-13T08:51:24Z")

</div>

Thanks, I needed the JS code for this.

---

<div class="post-metadata">

### Author: ![AriTheLion](https://avatars.discourse-cdn.com/v4/letter/a/5fc32e/32.png) [@AriTheLion](https://community.rapyd.net/u/AriTheLion)
#### Post date: [July 13, 2022, 9:12am UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/71 "2022-07-13T09:12:42Z")

</div>

Not clean or elegant but working in 2 seconds.  
Inspiration from [https://www.baeldung.com/java-solve-maze](https://www.baeldung.com/java-solve-maze)  
For the fun Im planning also to

1. Solve it with Prolog(but need to relearn)
2. Encode it to CNF expression and solve it with sat solver

```auto
package com.maze.app;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Puzzle 12 Arrow Maze
 */
public class App
{
    private static Cell[] maze;

    private int [] order = new int[64];
    private static int[] must = {1,16,17,52,44,43,14,10,45,27,15,28,60,59,26,63,61,55,54,56,33,64};
    private static int [][] direction =
            { {9,18,27,45,54},//0
                    {9,17,25,33,41,49,57},
                    {10,18,26,34,50,58},
                    {12,21,30,39},
                    {1,2,3},
                    {1,2,3,4},
                    {14,22,30,38,46,54,62},
                    {14,21,28,35,49,56},
                      {1},//8
                      {17,25,33,41,49,57},
                      {11},
                      {20,38,47},
                      {20,44,52,60},
                      {21,29,37,45,53,61},
                      {22,30,38,46,54,62},
                      {14,13,12,11,10,9,8},
                          {23},//16
                          {16},
                          {10,2},
                          {28},
                          {27,34,41,48},
                          {14,7},
                          {30,38,46,54,62},
                          {18,20,21},
                      {32,40,48,56},//24
                      {29},
                      {19,12,5},
                      {18,9},
                      {10},
                      {30,31},
                      {38,46,54,62},
                      {24,25,26,27,28,29,30},
                       {39},//32
                       {32},
                       {25},
                       {36,38},
                       {63},
                       {36,35,34,33},
                       {46,54,62},
                       {37,35},
                      {48,56},//40
                      {42,43,44,45,46,47},
                      {50},
                      {42},
                      {53,62},
                      {46,47},
                      {37,28,19,10,1},
                      {55,63},
                          {41,34,27,20,13,6},//48
                          {58},
                          {51,52,53,54,55},
                          {44,37,30,23},
                          {43,34,25,16},
                          {48,49,50,51,52},
                          {46,38,30,22,14,6},
                          {47,39,31,23,15,7},
                      {57,58,59,60,61,62},//56
                      {48},
                      {50,34,26,18,10,2},
                      {56,57,58},
                      {61,62},
                      {53,45,37,29,21,13,5},
                      {56,57,58,59,60,61},
                      {},
            } ;

    public static void main( String[] args )
    {
        maze = new Cell[64];
        initMaze();
        List<Integer> solution = solve(maze);
        System.out.println( solution );
    }

    static void initMaze(){
        for (int i = 0; i < 64; i++) {
            maze[i] =new Cell(-1,direction[i], false);
        }
        maze[0].setOrder(1);
        maze[0].setMust(true);
        maze[11].setOrder(17);
        maze[11].setMust(true);
        maze[12].setOrder(52);
        maze[12].setMust(true);
        maze[17].setOrder(43);
        maze[17].setMust(true);
        maze[19].setOrder(14);
        maze[19].setMust(true);
        maze[22].setOrder(10);
        maze[22].setMust(true);
        maze[23].setOrder(45);
        maze[23].setMust(true);
        maze[28].setOrder(15);
        maze[28].setMust(true);
        maze[29].setOrder(28);
        maze[29].setMust(true);
        maze[32].setOrder(60);
        maze[32].setMust(true);
        maze[34].setOrder(26);
        maze[34].setMust(true);
        maze[39].setOrder(61);
        maze[39].setMust(true);
        maze[43].setOrder(54);
        maze[43].setMust(true);
        maze[50].setOrder(56);
        maze[50].setMust(true);
        maze[59].setOrder(33);
        maze[59].setMust(true);
        maze[63].setOrder(64);
        maze[63].setMust(true);
        maze[16].setOrder(44);
        maze[16].setMust(true);
        maze[25].setOrder(27);
        maze[25].setMust(true);
        maze[33].setOrder(59);
        maze[33].setMust(true);
        maze[42].setOrder(55);
        maze[42].setMust(true);
        maze[36].setOrder(63);
        maze[36].setMust(true);
        maze[10].setOrder(16);
        maze[10].setMust(true);
    }

    public static List<Integer> solve(Cell[] maze) {
        List<Integer> path = new ArrayList<>();
        if (
                explore(
                        maze,
                        0,
                        1,
                        path
                )
        ) {
            return path;
        }
        return Collections.emptyList();
    }

    private static boolean explore(
            Cell[] maze, int index,int order, List<Integer> path) {
        if ((index==63 && order !=64)
                ||(maze[index].isMust() && (order != maze[index].getOrder()))
                || !valid(index,order)
                ||(!maze[index].isMust() && maze[index].getOrder() != -1 && (order != maze[index].getOrder()))){
            return false;
        }

        path.add(index);
        System.out.println("index:" +index + "added to path, order:"+ order);
        if (!maze[index].isMust()) {
            maze[index].setOrder(order);//setVisited
        }
        if (index ==63 || order == 64) {
            return true;
        }

        for (int i =0; i<maze[index].getDirection().length;i++ ) {
            if (
                    explore(
                            maze,
                            maze[index].getDirection()[i],
                            order+1,
                            path
                    )
            ) {
                return true;
            }
        }

        path.remove(path.size() - 1);
        if (!maze[index].isMust()){
            maze[index].setOrder(-1);
        }
        System.out.println(index +" index:"+ maze[path.size() - 1].getOrder() + "order removed");
        return false;
    }

    private static boolean valid(int index, int order) {
        return (!orderInMustlist(order) ||
                (index==0 && order==1)
                ||(index==10 && order==16)
                ||(index==11 && order==17)
                ||(index==12 && order==52)
                ||(index==16 && order==44)
                ||(index==17 && order==43)
                ||(index==19 && order==14)
                ||(index==22 && order==10)
                ||(index==23 && order==45)
                ||(index==25 && order==27)
                ||(index==28 && order==15)
                ||(index==29 && order==28)
                ||(index==32 && order==60)
                ||(index==33 && order==59)
                ||(index==34 && order==26)
                ||(index==36 && order==63)
                ||(index==39 && order==61)
                ||(index==42 && order==55)
                ||(index==43 && order==54)
                ||(index==50 && order==56)
                ||(index==59 && order==33)
                ||(index==63 && order==64));
    }

    private static boolean orderInMustlist(int order) {
        for (int i = 0; i < must.length; i++) {
            if (must[i]==order){
                return true;
            }
        }
        return false;
    }

    public static class Cell {

        private int order;
        private int[] direction;
        private boolean must;

        public int getOrder() {
            return order;
        }
        public void setOrder(int order) { this.order = order;}

        public int[] getDirection() {
            return direction;
        }

        public void setMust(boolean must) {
            this.must = must;
        }
        public boolean isMust() {
            return must;
        }

        public Cell(int order,int[] direction,boolean must){
            this.order = order;
            this.direction = direction;
            this.must = must;
        }
    }

}

```

---

<div class="post-metadata">

### Author: ![datascientist.py](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/datascientist.py/32/9090_2.png) [@datascientist.py](https://community.rapyd.net/u/datascientist.py)
#### Post date: [July 16, 2022, 10:27pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/72 "2022-07-16T22:27:15Z")

</div>

Hey guys,

I solved the puzzle with no code or guessing, I just used logic. Now, I got two questions:

- how can I check my solution?
- am I allowed to share my approach/ solution here? I mean the challenge is already expired.

Thank you

---

<div class="post-metadata">

### Author: ![MusaddiqueAli](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/musaddiqueali/32/3309_2.png) [@MusaddiqueAli](https://community.rapyd.net/u/MusaddiqueAli)
#### Post date: [July 17, 2022, 10:12am UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/73 "2022-07-17T10:12:01Z")

</div>

I’d love to know what logic you used to do solve it without coding. I tried to solve the Arrow Maze manually but never cracked the correct approach. I just know that going backward starting from 64 is the best approach but when the gaps of unknown numbers between two known numbers were large, there I couldn’t make much progress.

---

<div class="post-metadata">

### Author: ![just\_T3](https://avatars.discourse-cdn.com/v4/letter/j/ed655f/32.png) [@just\_T3](https://community.rapyd.net/u/just_T3)
#### Post date: [July 20, 2022, 3:25pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/74 "2022-07-20T15:25:09Z")

</div>

> [@datascientist.py](#):
>
> can

yeah I did that backwards approach but i started it too late. I have got into the flow of making time for these puzzles around my life tho now haha

---

<div class="post-metadata">

### Author: ![just\_T3](https://avatars.discourse-cdn.com/v4/letter/j/ed655f/32.png) [@just\_T3](https://community.rapyd.net/u/just_T3)
#### Post date: [July 20, 2022, 3:26pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/75 "2022-07-20T15:26:48Z")

</div>

I think you posted too late as the puzzle ended a while ago. You can enter the solution [here](https://www.hackthegalaxy.dev/solve/) but the deadline long passed so guess you wont be able to know if you where right

---

<div class="post-metadata">

### Author: ![MusaddiqueAli](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/musaddiqueali/32/3309_2.png) [@MusaddiqueAli](https://community.rapyd.net/u/MusaddiqueAli)
#### Post date: [July 20, 2022, 5:14pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/77 "2022-07-20T17:14:47Z")

</div>

I couldn’t solve it but got to know the 6 letter answer to the puzzle from someone else through a private message here.

---

<div class="post-metadata">

### Author: ![Sylthrim](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/sylthrim/32/8201_2.png) [@Sylthrim](https://community.rapyd.net/u/Sylthrim)
#### Post date: [July 20, 2022, 7:22pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/78 "2022-07-20T19:22:34Z")

</div>

I actually did it without coding and I jumped around a lot with the numbers doing the ones that I knew were 100% correct because no other number can fit there. I then placed colored dots(on Photoshop) on all possible outcomes with the ones that were left and eventually, a pattern started to appear. With the colored dots I was able to cross out dead ends until only 1 path was left.

---

<div class="post-metadata">

### Author: ![just\_T3](https://avatars.discourse-cdn.com/v4/letter/j/ed655f/32.png) [@just\_T3](https://community.rapyd.net/u/just_T3)
#### Post date: [July 20, 2022, 9:24pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/79 "2022-07-20T21:24:45Z")

</div>

> [@Sylthrim](#):
>
> started

that sounds cool, looking at the examples I understand how they did it but my python skills are lacking so I did not come up with a code solution

---

<div class="post-metadata">

### Author: ![just\_T3](https://avatars.discourse-cdn.com/v4/letter/j/ed655f/32.png) [@just\_T3](https://community.rapyd.net/u/just_T3)
#### Post date: [July 20, 2022, 9:25pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/80 "2022-07-20T21:25:06Z")

</div>

I treated it like a cryptic sudoku lol

---

<div class="post-metadata">

### Author: ![Aimar\_Baquedano](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/aimar_baquedano/32/1972_2.png) [@Aimar\_Baquedano](https://community.rapyd.net/u/Aimar_Baquedano)
#### Post date: [July 22, 2022, 5:00pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/81 "2022-07-22T17:00:39Z")

</div>

What an incredible and complicated puzzle. A couple of days ago I entered the competition and I love trying to solve the puzzles that have already expired even if they don’t help me win. Thank for doing this amazing puzzles!!!

---

<div class="post-metadata">

### Author: ![Timothy\_Breaux31](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/timothy_breaux31/32/13185_2.png) [@Timothy\_Breaux31](https://community.rapyd.net/u/Timothy_Breaux31)
#### Post date: [July 24, 2022, 9:59pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/82 "2022-07-24T21:59:16Z")

</div>

> [@galactic](#):
>
> `param`

How do i get to the arrow puzzle?  
@param

---

<div class="post-metadata">

### Author: ![Timothy\_Breaux31](https://sea2.discourse-cdn.com/flex016/user_avatar/community.rapyd.net/timothy_breaux31/32/13185_2.png) [@Timothy\_Breaux31](https://community.rapyd.net/u/Timothy_Breaux31)
#### Post date: [July 24, 2022, 10:02pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/83 "2022-07-24T22:02:08Z")

</div>

How do I get to these puzzle are is it to late?

---

<div class="post-metadata">

### Author: ![galactic](https://avatars.discourse-cdn.com/v4/letter/g/7cd45c/32.png) [@galactic](https://community.rapyd.net/u/galactic)
#### Post date: [July 24, 2022, 10:38pm UTC](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002/84 "2022-07-24T22:38:08Z")

</div>

You can see all puzzles from the past here [https://community.rapyd.net/c/hack-the-galaxy/challenges-archived/42](https://community.rapyd.net/c/hack-the-galaxy/challenges-archived/42)

[Previous page](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002.md?page=3)

[Next page](https://community.rapyd.net/t/thoughts-on-puzzle-12-arrow-maze/18002.md?page=5)