text:
Draw the Ingress glyphs
In the location-based AR mobile game way of life Ingress the player can hack things called portals in order to get items. (If you are interested in Ingress, you can ping me in chat for more info. Trust me, it's better than Pokémon. If you end up downloading it, remember to choose the Resistance.)
A way to increase hack output significantly is the glyph hacking minigame, in which the player has to draw glyphs on a hexagonal grid.

In total, there are about 115 glyphs with about 130 names that are actually used in the game.
Glyphs
For the purposes of this challenge we will number each point of the grid like so:

Here is the list of all the glyphs for the purposes of this challenge. The list is a JSON object, containing each glyph as a list of edges.
{
"ABANDON": [[1, 6], [3, 4], [4, 8], [6, 10], [8, 10]],
"ACCEPT": [[3, 7], [3, 8], [7, 8]],
"ADVANCE": [[0, 9], [4, 9]],
"AFTER": [[1, 2], [1, 6], [2, 7], [6, 10], [7, 10]],
"AGAIN": [[4, 9], [6, 7], [6, 10], [8, 9], [8, 10]],
"ALL": [[0, 1], [0, 5], [1, 2], [2, 3], [3, 4], [4, 5]],
"ANSWER": [[6, 7], [6, 9], [7, 10]],
"ATTACK": [[0, 6], [0, 9], [2, 6], [4, 9]],
"AVOID": [[0, 5], [0, 6], [1, 6], [1, 7]],
"BALANCE": [[0, 10], [2, 3], [2, 7], [3, 4], [4, 8], [7, 10], [8, 10]],
"BARRIER": [[0, 10], [2, 7], [7, 10]],
"BEFORE": [[4, 5], [4, 8], [5, 9], [8, 10], [9, 10]],
"BEGIN": [[0, 8], [3, 7], [3, 8]],
"BODY": [[6, 9], [6, 10], [9, 10]],
"BREATHE": [[1, 6], [5, 9], [6, 10], [9, 10]],
"CAPTURE": [[1, 7], [3, 4], [4, 8], [7, 10], [8, 10]],
"CHANGE": [[3, 7], [3, 10], [8, 10]],
"CHAOS": [[0, 1], [0, 5], [1, 6], [3, 8], [4, 5], [6, 10], [8, 10]],
"CIVILIZATION": [[1, 6], [5, 9], [6, 7], [7, 8], [8, 9]],
"CLEAR": [[0, 10], [3, 10]],
"CLEAR ALL": [[0, 1], [0, 5], [0, 10], [1, 2], [2, 3], [3, 4], [3, 10], [4, 5]],
"COMPLEX": [[6, 9], [8, 10], [9, 10]],
"CONFLICT": [[2, 6], [4, 9], [6, 7], [7, 8], [8, 9]],
"CONTEMPLATE": [[0, 1], [1, 2], [2, 3], [3, 8], [6, 10], [8, 9], [9, 10]],
"COURAGE": [[4, 9], [7, 8], [8, 9]],
"CREATE": [[1, 6], [4, 8], [6, 10], [8, 10]],
"DANGER": [[0, 9], [3, 10], [9, 10]],
"DATA": [[0, 6], [3, 8], [6, 10], [8, 10]],
"DEFEND": [[1, 7], [3, 7], [3, 8], [5, 8]],
"DESTINY": [[3, 8], [6, 7], [6, 10], [7, 8], [9, 10]],
"DESTROY": [[2, 7], [5, 9], [7, 10], [9, 10]],
"DETERIORATE": [[4, 8], [8, 10], [9, 10]],
"DIE": [[2, 7], [4, 8], [7, 10], [8, 10]],
"DIFFICULT": [[1, 6], [6, 7], [7, 10], [8, 10]],
"DISCOVER": [[1, 2], [2, 3], [3, 4]],
"DISTANCE": [[0, 5], [4, 5]],
"EASY": [[3, 8], [6, 10], [8, 10]],
"END": [[0, 1], [0, 10], [1, 7], [3, 7], [3, 10]],
"ENLIGHTENED": [[0, 1], [0, 9], [1, 2], [2, 3], [6, 9], [6, 10], [9, 10]],
"ENLIGHTENMENT": [[0, 1], [0, 9], [1, 2], [2, 3], [6, 9], [6, 10], [9, 10]],
"EQUAL": [[6, 7], [6, 9], [8, 9]],
"ESCAPE": [[0, 1], [1, 6], [6, 9], [8, 9]],
"EVOLUTION": [[0, 10], [8, 9], [9, 10]],
"FAILURE": [[0, 10], [6, 7], [6, 10]],
"FEAR": [[1, 7], [6, 7], [6, 9]],
"FOLLOW": [[0, 6], [1, 2], [1, 6]],
"FORGET": [[4, 8]],
"FUTURE": [[1, 6], [2, 7], [6, 7]],
"GAIN": [[5, 8]],
"GROW": [[4, 9], [8, 9]],
"HARM": [[0, 6], [0, 9], [2, 7], [6, 10], [7, 10], [9, 10]],
"HARMONY": [[0, 6], [0, 9], [3, 7], [3, 8], [6, 10], [7, 10], [8, 10], [9, 10]],
"HAVE": [[3, 8], [7, 10], [8, 10]],
"HELP": [[5, 9], [7, 8], [8, 10], [9, 10]],
"HIDE": [[1, 6], [1, 7], [6, 9], [7, 8]],
"HUMAN": [[3, 7], [3, 8], [6, 7], [6, 9], [8, 9]],
"IDEA": [[1, 2], [1, 6], [2, 7], [4, 5], [4, 8], [5, 9], [7, 10], [9, 10]],
"IGNORE": [[2, 7]],
"IMPERFECT": [[6, 8], [6, 10], [8, 9], [8, 10], [9, 10]],
"IMPROVE": [[1, 6], [6, 10], [7, 10]],
"IMPURE": [[3, 10], [8, 9], [8, 10], [9, 10]],
"INSIDE": [[6, 7], [6, 9]],
"INTELLIGENCE": [[1, 6], [4, 8], [6, 10], [8, 9], [9, 10]],
"INTERRUPT": [[0, 10], [3, 10], [4, 5], [4, 8], [5, 9], [8, 10], [9, 10]],
"JOURNEY": [[1, 6], [2, 3], [3, 4], [4, 5], [5, 9], [6, 10], [9, 10]],
"KNOWLEDGE": [[3, 6], [3, 9], [6, 10], [9, 10]],
"LEAD": [[0, 5], [3, 8], [4, 5], [4, 8]],
"LEGACY": [[0, 1], [0, 5], [1, 6], [2, 7], [4, 8], [5, 9], [6, 7], [8, 9]],
"LESS": [[6, 10], [9, 10]],
"LIBERATE": [[0, 1], [1, 6], [4, 9], [6, 10], [9, 10]],
"LIE": [[6, 7], [6, 10], [7, 10], [8, 9], [9, 10]],
"LOSE": [[1, 7]],
"MESSAGE": [[1, 7], [4, 9], [7, 10], [9, 10]],
"MIND": [[3, 8], [3, 10], [8, 9], [9, 10]],
"MORE": [[7, 10], [8, 10]],
"MYSTERY": [[0, 6], [0, 9], [5, 9], [6, 9], [8, 9]],
"N'ZEER": [[0, 6], [0, 9], [0, 10], [3, 10], [6, 10], [9, 10]],
"NATURE": [[2, 7], [4, 8], [6, 7], [6, 9], [8, 9]],
"NEW": [[2, 7], [6, 7]],
"NO": [[6, 7], [6, 9]],
"NOT": [[6, 7], [6, 9]],
"NOURISH": [[3, 4], [3, 10], [4, 8], [8, 10]],
"NOW": [[6, 7], [7, 8], [8, 9]],
"OLD": [[5, 9], [8, 9]],
"OPEN": [[3, 7], [3, 8], [7, 8]],
"OPEN ALL": [[0, 1], [0, 5], [1, 2], [2, 3], [3, 4], [3, 7], [3, 8], [4, 5], [7, 8]],
"OUTSIDE": [[0, 5], [4, 5]],
"PAST": [[4, 8], [5, 9], [8, 9]],
"PATH": [[0, 10], [4, 8], [8, 10]],
"PEACE": [[0, 6], [0, 9], [3, 7], [3, 8], [6, 10], [7, 10], [8, 10], [9, 10]],
"PERFECTION": [[0, 10], [2, 3], [2, 7], [3, 4], [4, 8], [7, 10], [8, 10]],
"PERSPECTIVE": [[0, 6], [0, 9], [2, 7], [4, 8], [6, 10], [7, 10], [8, 10], [9, 10]],
"PORTAL": [[1, 2], [1, 6], [2, 7], [4, 5], [4, 8], [5, 9], [6, 9], [7, 8]],
"POTENTIAL": [[0, 10], [1, 2], [2, 7], [7, 10]],
"PRESENT": [[6, 7], [7, 8], [8, 9]],
"PURE": [[0, 10], [6, 7], [6, 10], [7, 10]],
"PURSUE": [[0, 6], [0, 9], [5, 9]],
"QUESTION": [[0, 6], [6, 9], [8, 9]],
"REACT": [[2, 7], [6, 9], [7, 10], [9, 10]],
"REBEL": [[1, 2], [1, 6], [5, 8], [6, 10], [8, 10]],
"RECHARGE": [[0, 5], [0, 10], [5, 9], [9, 10]],
"REPAIR": [[0, 5], [0, 10], [5, 9], [9, 10]],
"REPEAT": [[4, 9], [6, 7], [6, 10], [8, 9], [8, 10]],
"RESISTANCE": [[0, 9], [0, 10], [3, 8], [3, 10], [6, 9]],
"RESTRAINT": [[2, 3], [2, 7], [5, 9], [7, 10], [9, 10]],
"RETREAT": [[0, 6], [2, 6]],
"SAFETY": [[2, 6], [4, 9], [6, 9]],
"SAVE": [[1, 7], [7, 10], [8, 10]],
"SEARCH": [[6, 9], [6, 10], [7, 8], [8, 9]],
"SEE": [[0, 9]],
"SEPARATE": [[2, 7], [5, 9], [6, 7], [6, 10], [8, 9], [8, 10]],
"SHAPER": [[0, 6], [0, 9], [2, 7], [4, 8], [6, 7], [8, 9]],
"SIMPLE": [[7, 8]],
"SOUL": [[3, 7], [3, 10], [6, 7], [6, 10]],
"STABILITY": [[2, 7], [4, 8], [7, 8]],
"STAY": [[2, 7], [4, 8], [7, 8]],
"STRONG": [[6, 7], [6, 9], [7, 8], [8, 9]],
"STRUGGLE": [[0, 9], [0, 10], [3, 8], [3, 10], [6, 9]],
"SUCCESS": [[0, 10], [8, 9], [9, 10]],
"TECHNOLOGY": [[1, 6], [2, 7], [6, 10], [7, 10], [8, 9], [8, 10], [9, 10]],
"THOUGHT": [[1, 2], [1, 6], [2, 7], [4, 5], [4, 8], [5, 9], [7, 10], [9, 10]],
"TOGETHER": [[4, 8], [6, 9], [6, 10], [8, 10], [9, 10]],
"TRUTH": [[6, 7], [6, 10], [7, 10], [8, 9], [8, 10], [9, 10]],
"UNBOUNDED": [[0, 1], [0, 5], [1, 7], [2, 3], [3, 4], [4, 5], [6, 9], [6, 10], [7, 8], [8, 9]],
"US": [[3, 6], [6, 9]],
"USE": [[1, 7], [7, 10]],
"WANT": [[3, 7], [3, 8], [4, 8]],
"WAR": [[0, 6], [0, 9], [2, 6], [4, 9]],
"WEAK": [[5, 9], [6, 7], [6, 9]],
"XM": [[6, 7], [6, 9], [7, 10], [8, 9], [8, 10]],
"YOU": [[0, 7], [0, 8], [7, 8]],
"YOUR": [[0, 7], [0, 8], [7, 8]]
}

Some glyphs have multiple names (e.g. NO, NOT, INSIDE); you must support them all.
Disclaimer: I couldn't find a good list of all of the glyphs, so I combined multiple sources and finally ended up drawing all of them in a hacked-together JS application to get the list of them. I may be missing some and there may be a couple of aliases not used in the game; I hope I didn't misdraw some of the glyphs, though.
Edit the next morning when it's not 4am: I already noticed VICTORY is missing. Oh well, it's left for the best golfer then.
Challenge
Your task is to create a program or function that takes in a name of a glyph, and outputs the glyph as an image.
The image must contain the grid points and the lines connecting the points in question.
This is code-golf, so the shortest answer in bytes wins. Standard rules apply.
I/O
You will take as input, in a format of your choice, a name of a glyph exactly as found in the keys of the above JSON object. Any other input is undefined behavior.
You will output an image in any common format with the glyph rendered to the grid.
Grid proportions
These proportions must be accurate to five pixels (to allow for rounding etc.)

The outer points (0-5) must form a regular hexagon.
The center point (10) must be in the center of the hexagon.
The intermediate points (6-9) must be halfway between the center point and the corresponding outer points.
The grid must be oriented like the original.
The height of the outer hexagon must be at least 100 pixels.

Other rules

The background must be either transparent or filled with a solid color.
The lines and points must be clearly distinct from the background and each other; they cannot be of the same solid color.

For example, solid blue lines and solid pink points is fine.
Solid black lines and white points with black borders is fine.
Red and white striped lines and footballs as points is fine.
Solid green lines and solid green points is not fine.

The radius of the points must be larger than the width of the lines.
You may draw the lines in front of or behind the points.
You may include any amount of padding (in the background color) in the image.
You may combine consecutive lines into one line, since it doesn't affect the outcome.

Examples
The colors and object widths in these images are just examples that somewhat resemble the appearance of the game.
UNBOUNDED

PEACE

RESISTANCE

Had to upvote for the nostalgia (and the Resistance suggestion :P). I wish I still had time for this game! Some of the most fun (and exercise) I've had in a long time. And did you actually manually create that JSON?

@Carcigenate No. I wrote a piece of code that gave me a grid and a name of a glyph and had me draw it, and collected the glyphs in an array as lists of nodes. Then it was just ten lines of python and some find-and-replace. That app is also where the examples come from.

while compressing the list of graph plays a big part in the challenge, i don't think the kolmogorov tag feat here as you have more than hundred different output

@Pietu1998 Oh, cool. Guess I should have trusted that a programmer would have written a program to help with something like that.

Mathematica, 228 + 184 + 365 + 13 = 790 bytes
Graphics@{v=255#+##&~Fold~BinaryReadList@#~IntegerDigits~#2&;p=#~Partition~2&;c=p["c"~v~25-12][[#+1]]&;Array[Disk@*c,11,0],Red,Line[c/@<|Thread["a"~v~2293->First/@p@SplitBy["b"~v~12,#>10&]]|>@Mod[1##&@@ToCharacterCode@#,2293]]}&

The above 228-byte command defines an unnamed function that takes as input one of the glyph names above, and returns an image. For example, here is the output for "UNBOUNDED":

The command reads three binary files—"a", "b", and "c"—which have 184, 365, and 13 bytes, respectively. An easier-to-read version:
1  Graphics@{
2    v = 255#+##&~Fold~BinaryReadList@#~IntegerDigits~#2 &;
3    p = #~Partition~2 &;
4    c = p["c"~v~25-12][[#+1]] &;
5    Array[Disk@*c, 11, 0], Red,
6    Line[c /@
7      <| Thread[ "a"~v~2293 -> First/@p@SplitBy["b"~v~12, #>10&] ] |>
8        @ Mod[1##& @@ ToCharacterCode@#, 2293]]
9  } &

Line 2 defines a handmade uncompression function: it reads in a stream of bytes from the file #, converts it into a base-256 integer, and then expands that integer into its list of digits in base #2. Lines 3 and 4 define a function (using the third binary file) that converts an integer from 0 to 10 into the coordinates of the corresponding grid point; all these coordinates were chosen to be integers between –12 and 12, which makes compression convenient (though not so convenient that I saw it for my initial submission).
Line 5 draws the grid points (in default color black), then switches to the color red for the lines. Line 7 creates an association (using the first two binary files) that converts certain input integers between 0 and 2292 into a list of grid-point integers such as {2, 3, 4, 5, 0, 1, 7, 8, 9, 6, 10}, which represents a path joining point 2 to 3 to 4 to ... to 10. (This is an "Eulerian path", one that visits each edge exactly once; all the glyphs in the table have an Eulerian path, so this representation is shorter than listing the set of edges explicitly.) The command after the -> on line 7 creates this list of Eulerian paths, by reading in a base-12 integer using v and then splitting it at every occurrence of the digit 11.
Finally, line 8 hashes the input string by converting all its letters to their ASCII codes and taking their product modulo 2293 (the smallest modulus for which the answers are all distinct). That integer is fed into the association in the line above, resulting in the appropriate Eulerian path, and line 6 draws the resulting path over the grid points.
Hex dumps of files "a", "b", and "c", in that order:
09d5f27cd2246e0cb06aa243b442d761ac3a5604439f1767a202c4d3fc4fc1b24ce59acfc65a05235cc46354af8820d6733001e1f25ea01479cee027d62e8b1be10891c693ed5887942ca461c461d458a7676bfcd866a70263ad1833b3e836895ce121153c451ad327086e2bd30d6bad7097a9e71c2fc67c2c57716e5ada6907d99f42702dfb8b88c6d26799aa01f42fb89394e00b0752825f2740903276e20ec405473f309cc978aea187da24749d0a44319cd7322dd542

02d9ebf5fc94183ce50f0fc84e88a27bd21a3b3665d54949608c75c86c4507eed3072e02657822bfb83dbca8a708e07d1382c2b6c3c8fcddc88fa7244281a918b3a8aa823048d4a7e070a336c1e5ab83ec4950fc1960f34c6b89c541c9401607882418cac7f79f4edb164b775ecbb97947470016cadea4d06f93a958713b8c23d11be3c9ce8a2824a458d151ac3cafc6d7bb1557e55868434bd5c0da4bd71e66a3f7711018ae5e7f2941a949a85b6e65aebcc2fe43a89cb0479fa9474fe5102cfbf7da8a455f46ac5409dfdc79970ed8dbfc6b84df78c9c19df4d16bda298dca445ad510bf32e14ca5c91ce58e7521492f6e79e05624ab4a4c02c66c22ef670a06d5c5a3dfdf8ccc8c40c353f3aecf17bbb5cb911baefa3ce80e41551376838c166153a1038d83e171077a3f260ccd70358917eeceb5722b58ad6900a40b5b1512b292fb7a7e0d2cbe2bac2a48a4e343e8f2a338808ec9957c64778aba412bec47bcabb2a2789f01c2d5fdd993

254c40dac61bb215386b7361a8

Nice answer! You should post the hexdumps of your data files, though.

Done ... and meanwhile I realized that I might as well just compress the list of grid-point coordinates as well, since all the relevant commands are already present.


text:
Fraction Frenzy!
EDIT: I'm getting a lot of comments about this not terminating - I will give the "correct answer" tag to either the first person who gives me FF(3) (as in provides it in their answer) or proves that FF(3) does indeed blow up indefinitely.
Task:
Your task is make the smallest program possible that generates the list of reciprocals of the Fraction Frenzy function (FF(n)) given a positive integer n.
Introduction:
Before I can introduce the FF function, I have to first explain Egyptian fractions.
Egyptian Fractions:
Egyptian fractions are a way of expressing fractions as the sum of distinct unit fractions - so one way to express the fraction 5/8 is 1/2 + 1/8. It is not other fraction sums like
1/4 + 1/4 + 1/8
1/2 + 1/16 + 1/16

because not all of their fractions are distinct (1/4 is repeated in the first example, and 1/16 in the second).
In our definition of Egyptian fractions, we are including the use of negative denominators in the unit fractions as well.
FF function:
The FF (Fraction Frenzy) function is described like so:
FF(1) is the Egyptian fraction 1/2 + 1/3 + 1/5 + 1/-30.
FF(2) is equal to FF(1) "multiplied" by itself (FF(1) "squared"):
  (1/2 + 1/3 + 1/5 + 1/-30)(1/2 + 1/3 + 1/5 + 1/-30)
= 1/4 + 1/6 + 1/10 + 1/-60 + 1/6 + 1/9 + 1/15 + 1/-90 +
  1/10 + 1/15 + 1/25 + 1/-150 + 1/-60 + 1/-90 + 1/-150 + 1/900

This is not a fully reduced Egyptian fraction yet, because there are "repeats" in fractions. To reduce them, the following procedure is done:

Sum all "like" unit fractions together.
Reduce the sums to their simplest forms - so for example, if a sum from step 1 is 2/6, that can be reduced to 1/3.
Repeat 1 and 2 until all denominators are distinct: for example, 1/2 + 2/3 + 1/5, as opposed to 1/2 + 1/3 + 1/3, which has a repeating denominator 3.
If there is a pair of one positive and one negative fraction that have an equal absolute value, remove both of them (e.g. 1/-5 and 1/5 must both be removed).
If fractions are not unit and cannot be reduced further, split it up into unit fractions with a equal denominator, and keep one fraction as it is. With the other ones, multiply them by FF(1): (1/2 + 1/3 + 1/5 + 1/-30).
Repeat steps 1-5 until the final fraction sum is a valid Egyptian fraction - i.e. all fractions are distinct from one another, and they are all unit fractions.

This is the reduction of FF(2):
  1/4 + 1/6 + 1/10 + 1/-60 + 1/6 + 1/9 + 1/15 + 1/-90 +
  1/10 + 1/15 + 1/25 + 1/-150 + 1/-60 + 1/-90 + 1/-150 + 1/900
= 1/4 + 2/6 + 1/9 + 2/10 + 2/15 + 1/25 + 2/-60 + 2/-90 + 2/-150 + 1/900 (step 1)
= 1/4 + 1/3 + 1/9 + 1/5 + 2/15 + 1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900   (step 2)
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/15(1/2 + 1/3 + 1/5 + 1/-30) +        (step 5)
  1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/30 + 1/45 + 1/75 + 1/-450 +
  1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/25 + 1/-450 + 1/900                  (step 4)

For all n (except for 1), FF(n) is defined by "squaring" FF(n-1).
Input and Output:
Given an integer n, you must output a list all of the reciprocals of FF(n), sorted in ascending order of their absolute values:
1 -> [2, 3, 5, -30]
# 1/2 + 1/3 + 1/5 + 1/-30 = FF(1), reciprocals = [2, 3, 5, -30]

2 -> [3, 4, 5, 9, 15, 25, -450, 900]

You are allowed to use a string with any delimiter, or your language's interpretation of a list, so these outputs are all acceptable with the input 1:
2 3 5 -30   (Space-delimited)
2,3,5,-30   (Comma-delimited)
[2 3 5 -30] (Lisp-like lists)
etc. etc.

Specs:

You must output the results of the FF(n) function exactly as specified above.
You are guaranteed that the input will be a positive integer - it will never be below zero, and it will never be a decimal (or fraction).

This is code-golf, so shortest code in bytes wins!

Out of curiosity, is this guaranteed to terminate?

Let us continue this discussion in chat.

I confirm that FF(3) seems to blow up. Did you not test this up to about FF(10) before posting to the sandbox?

Let us continue this discussion in chat.

until all reciprocals are distinct -- Can you clarify what this means?

until the final fraction sum is a valid Egyptian fraction -- This too. The example suggests that step 4 has to be applied again if it causes a change, even though that's not part of the stated definition of an Egyptian fraction. Maybe you mean "until it doesn't change anymore", in both cases?

F(3) doesn't appear to terminate for me, either. See here for my non-golfed program and its debug output, written under the assumption that we need to iterate until it doesn't change anymore.

Egyptian fractions didn't have negative values in them, so it's not really an Egyptian fraction.

@mbomb007 Fixed as well.

@smls Finished editing for both of your queries.

I think step 6, as written, still doesn't explain why step 4 (canceling out negatives) is performed at the end of the reduction of FF(2), since the result of previous step 5 already consisted of distinct unit fractions - just not with distinct absolute values.

@smls Yeah... didn't put that in, nice catch.

Haskell, 365 bytes
import Data.Function;import Data.List;import Data.Ratio;n=numerator;d=denominator
r=until=<<((==)=<<)$filter(/=0).map(sum).groupBy((==)`on`d).sortBy(compare`on`d)
p s=let(o,q)=span((<2).abs.n)s in case q of []->o;(a:b)->let j=a-1%d a*signum a in p.r$o++[a-j]++map(*j)e++b
s s=(*)<$>s<*>s;e=(1%)<$>[2,3,5,-30];f=iterate(p.r.s)e;o i=[abs(d q)*signum(n q)|q<-f!!(i-1)]

Try it online!

Hmm… i run into an apparently infinite loop when splitting the largest non-unit and rechecking at a time as presented and had already done so when splitting the smallest non-unit in leftwards reverse or globally all non-units before rechecking but perhaps i should not fail to nondeterministically pick non-units from in between whether one cancels out enough others to reach a finite FF(3)?

Using (1%)<$>[2,4,6,12] as 1 merely procrastinates the nontermination from FF(3) to FF(4)

(1%)<$>[2,3,10,15] or (1%)<$>[3,4,6,8,12,24] yield no improvement at all

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Find letter-similar words in a word list
(I am not sure that this is the best place to put this question, but I will give it a shot. Forgive me if it is improper. This is just a fun project with which I am tinkering and I am looking for advice on how best to implement it; but it is also something of a 'challenge' (not implying that it is hard!), so I thought that it might fit here)
Here is the basics of the problem.
I have a list of words (strings); basically, it is a partial dictionary in a language but nothing but the words are included. I want to check whether I can make any of the following exchanges in their spelling exactly once and yet still generate a word which is already present in the list:
• (b f)
• (p v)
• (c z)
• (j s)
By "exchange exactly once", I mean that only one occurrence of one letter in a word gets switched to its partner.
If such an exchange produces a word in the list, then I want to be notified about it (by printing the pair of words and moving to the next line). I want to check the whole word list for any pair of words such that if exactly one occurrence of one of these letters in them is changed to the partner letter, then the new word is also in the list (being the other word).
To be clear, these are not all of the consonants which are present in the word list; there are also vowels. These letters are just pairs which I want to exchange.
So, "bats" would become "fats" and vice-versa, and perhaps both of those words are in the list; if so, then the check would tell me so. On the other hand, "baba" would generate "faba" or "bafa" (and vice-versa), but not "fafa" (because that would be exchanging two occurrences of one letter); likewise, "jazz" would generate "sazz", "jacz", and "jazc", but nothing else;  none of the generated words in this example would be in an English word list.
There are additional constraints on the list though, which are helpful:
• Every word in the list is four letters long (so I do not need to check string lengths).
• No occurrence of a letter can be adjacent to another occurrence of the same letter. So, "jazz" does not occur in the list because there is the substring "zz", which adjacently repeats a letter.
• "b", "j", "v", and "z" may be mutually adjacent, and "p", "c", "f", and "s" may be mutually adjacent, but none of those first four characters can be adjacent to any of the second four characters.
• All words in the list are of the form 'CVCC' or the form 'CCVC', where 'C' represents a consonant and 'V' represents a vowel. This means that the list is partitioned into two classes of words.
The word list is approximately one thousand five hundred (1500) words long.

I want to do this efficiently. A really simply effort, which I will describe, seems rather poor.
This effort would be this:
0) Look at the file of words. Sort the word list alphabetically. (It comes this way)
1) Run through the word list and discard any of the words which lack any of these letters: "b", "p", "v", "f", "z", "s", "j", "c". Counting multiplicities (words which have multiple occurrences of these letters get counted as many times as there are occurrences), the list has N words; in other terms, these letters occur N times in the word list.
2) Sort the word list into two sublists based on the form of the words (put them into two different files and close the original one, then open each of these new files in turn?). One will have $N_1$ words and the other will have $N_2$ words, counting multiplicities (where $N_1 + N_2 = N$). It turns out that $N_1, N_2 > 300$.
3) Now, in each list, run through and compare each occurrence of a letter against the corresponding letter in each subsequent word. So, the first word will be checked against the second, third, fourth, ..., nth words - but really, the ith letter in the first word will be checked against the ith letter in the jth word, running over all $i \in [1,4], j>1$; then the second word will be compared against the third, fourth, fifth, ..., nth words; ...; all the way down to the penultimate word, which will end the loop. Comparison will just at most three checks (see if the first letters form such a pair, see if the second consonants form such a pair, see if the third consonants form such a pair; if the ith consonant of the word being checked against all of the subsequent words is not one of these letters, then we can ignore the ith consonant in all of the checks and move on to the (i+1)st consonant).
(I should say that words may differ in only their vowel without notifying me, such as "fats" and "fits". This is okay and I do not want to be notified about these pairs.)
4) If a word differs by only one occurrence of a letter from another word and the differing letters are one of the pairs which I mentioned, then print both words (separated by a space) and move to a new line.
Done.
Now, this is really slow. I think that it takes at least $(N1-1)! + (N2-1)!$ comparisons. I can speed it up a bit (for example: since the sorting is alphabetic, I know that "b"-initial words could/should be checked against only "f"-initial words for their first consonant (I do not need to run through the whole list - just the "f"-initial section of it) - but this is only for the first letters, and it makes the code somewhat less elegant).
Is there any better way to do this?
(If we are framing it as a challenge: Produce the method which needs to do the least number of comparisons. Ties will be broken in favor of code 'elegance' and brevity (in bytes).)

I am most familiar with C++ and want to do it in that language if possible. But I will take any advice or code which works.

Shouldn't this go to Stack Overflow?

Do you think so? I was not sure. I will post it there in any case.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Life is a Maze: We take the wrong Path before we learnt to walk
Input:
A maze containing the characters:

-- (horizontal wall);
| (vertical wall);
+ (connection);
 (walking space);
I (entrance);
U (exit).

I.e. an input could look like this:
 +--+--+--+--+--+--+--+--+--+--+
I               |     |        |
 +  +--+--+--+  +  +  +  +--+  +
 |           |     |  |  |     |
 +--+--+--+  +--+--+  +  +  +--+
 |           |     |     |     |
 +  +--+--+  +  +--+--+  +--+  +
 |     |     |     |     |     |
 +--+  +  +--+--+  +--+--+  +  +
 |     |        |        |  |  |
 +  +--+--+--+  +--+--+  +  +  +
 |     |     |     |        |  |
 +--+  +  +--+--+  +--+--+--+--+
 |  |  |                 |     |
 +  +  +--+--+--+  +--+  +  +  +
 |     |        |  |  |  |  |  |
 +--+--+  +  +--+  +  +  +--+  +
 |        |     |     |  |     |
 +  +--+--+--+  +  +  +  +  +--+
 |           |     |  |         U
 +--+--+--+--+--+--+--+--+--+--+

Output:
The most efficient path you should walk to get from the entrance to the exit of the maze (through the maze), indicated by the characters indicating left, right, up and down (i.e. >; <; ^; v).
Challenge rules:

You can take the input in any reasonable format. String-array, single String with new-lines, 2D char-array, etc. are all possible input formats.
The output can consist of any four distinct characters. I.e. ><^v; →←↑↓; ⇒⇐⇑⇓; RLUD; 0123; ABCD; etc.).
You are allowed to add spaces or trailing new-line to the output if preferred; this is optional.
The steps are counted per square (see four +-symbols for the squares), and not per character.
The maze can be of size 5x5 through 15x15, and will always be a square (so there won't be any test cases for 5x10 mazes).
You can assume that every maze has one or more valid paths from start to finish, and you always output the shortest (see test cases 4 and 5).
If there are multiple paths with the same length, you can choose which one to output (see test case 6).
You cannot 'walk' outside the borders of the maze (see test cases 7 and 8).

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.

Test cases:
1. Input:
 +--+--+--+--+--+--+--+--+--+--+
I               |     |        |
 +  +--+--+--+  +  +  +  +--+  +
 |           |     |  |  |     |
 +--+--+--+  +--+--+  +  +  +--+
 |           |     |     |     |
 +  +--+--+  +  +--+--+  +--+  +
 |     |     |     |     |     |
 +--+  +  +--+--+  +--+--+  +  +
 |     |        |        |  |  |
 +  +--+--+--+  +--+--+  +  +  +
 |     |     |     |        |  |
 +--+  +  +--+--+  +--+--+--+--+
 |  |  |                 |     |
 +  +  +--+--+--+  +--+  +  +  +
 |     |        |  |  |  |  |  |
 +--+--+  +  +--+  +  +  +--+  +
 |        |     |     |  |     |
 +  +--+--+--+  +  +  +  +  +--+
 |           |     |  |         U
 +--+--+--+--+--+--+--+--+--+--+

1. Output:
>v>>>vv<v>>v>v>>vvv>>>

2. Input:
 +--+--+--+--+--+
I   |        |  |
 +  +--+--+  +  +
 |        |  |  |
 +  +--+  +  +  +
 |  |  |     |  |
 +  +  +--+  +  +
 |        |     |
 +--+  +  +--+--+
 |     |         U
 +--+--+--+--+--+

2. Output:
>vvv>>v>>>

3. Input:
 +--+--+--+--+--+
U      |        |
 +  +  +--+--+  +
 |  |     |     |
 +--+--+  +  +--+
 |        |     |
 +  +--+--+--+  +
 |  |     |     |
 +  +  +  +  +--+
 |     |         I
 +--+--+--+--+--+

3. Output:
<<<^<v<^^>>^<^<<

4. Input (test case with two valid paths):
 +--+--+--+--+--+
U      |        |
 +  +  +--+--+  +
 |  |           |
 +--+--+  +  +--+
 |        |     |
 +  +--+--+--+  +
 |  |     |     |
 +  +  +  +  +--+
 |     |         I
 +--+--+--+--+--+

4. Output:
<<^>^<^<<^<<     (<<<^<v<^^>>^<^<< is less efficient, and therefore not a valid output)

5. Input (test case with two valid paths):
                               I
+--+--+--+--+--+--+--+--+--+--+  +--+--+--+--+
|     |              |                    |  |
+  +  +  +--+--+--+  +  +--+--+  +--+--+  +  +
|  |     |        |     |        |     |     |
+--+--+--+  +--+  +  +--+--+--+--+  +--+--+--+
|     |  |  |  |     |     |           |     |
+  +  +  +  +  +--+  +  +  +  +--+--+  +--+  +
|  |        |        |  |     |        |     |
+  +--+--+--+  +--+--+  +  +--+  +--+--+  +--+
|  |     |     |        |  |     |     |     |
+  +--+  +  +--+  +--+--+  +--+--+  +  +--+  +
|  |     |        |     |           |        |
+  +  +--+--+--+--+  +  +--+--+--+  +--+  +--+
|     |     |        |        |  |     |     |
+--+--+--+  +  +--+--+  +--+  +  +--+  +--+  +
|              |     |     |        |  |  |  |
+  +--+--+--+--+  +  +  +--+--+--+  +  +  +  +
|     |  |     |  |  |        |        |  |  |
+--+  +  +  +  +  +  +--+--+  +  +  +--+  +  +
|     |     |  |  |  |           |  |     |  |
+--+  +--+--+  +  +  +  +--+--+--+  +  +  +  +
|     |        |  |  |     |        |  |  |  |
+  +--+  +--+--+  +  +--+--+  +  +--+  +  +  +
|        |     |  |     |     |  |     |  |  |
+--+--+--+  +  +  +--+  +  +--+--+  +--+  +  +
|  |        |        |     |        |     |  |
+  +  +--+--+--+--+  +--+--+  +--+--+  +--+  +
|  |              |              |     |     |
+  +  +  +--+--+--+--+--+--+--+--+  +--+  +--+
|     |                                |     |
+--+--+--+--+--+--+--+--+--+  +--+--+--+--+--+
                            U

5. Output:
v<<<v<vv<<v<v>>^>>^^>vvv>>>v>vv<vv<<v<v<^<^^^^<vvvvv<^<v<<v>v>>>>>>>v     (v<<<v<vv<<v<v>>^>>^^>vvv>>>v>vv<vv<<v<v<^<^^^^<vvvvv>v>>>^>>^>^^>vvv<v<v<<v is less efficient, and therefore not a valid output)

6. Input:
 +--+--+--+--+--+
I               |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |              |
 +  +  +  +  +  +
 |               U
 +--+--+--+--+--+

6. Output:
>>v>v>v>v> or >v>v>v>v>> or >>>>>vvvv> or etc. (all are equally efficient, so all 10-length outputs are valid)

7. Input:
 I  U
+  +  +--+--+--+
|  |        |  |
+  +--+--+  +  +
|     |     |  |
+--+  +  +--+  +
|        |  |  |
+  +--+  +  +  +
|     |        |
+--+  +--+--+  +
|     |        |
+--+--+--+--+--+

7. Output:
vv>v>^>^<<^

8. Input:
 +--+--+--+--+--+
 |     |        |
 +  +--+  +--+  +
I   |     |  |  |
 +  +  +--+  +  +
U   |     |  |  |
 +--+--+  +  +  +
 |     |     |  |
 +  +--+--+--+  +
 |
 +--+--+--+--+--+

8. Output:
>v<

Mazes generated using this tool (and in some cases slightly modified).

Related 1; Related 2. (Been in the Sandbox since October 2016.)

I've found a shorter solution for the third test case! v<<<<<<^^^^^ (always think outside the box)

If one can prove that their code will yield the shortest solution, given enough time and memory, does it compete? Even in the case of a really long running time (end of the universe fashion)?

@Leo Which one's the third? That solution doesn't work for any I could think of as the third.

@JackBates It's a joke. He literally walks around the box to the exit :D

I think the first test case is wrong, it should be >v>>>vv<v>>v>v>>vvv>>>.

@TuukkaX Oh. Didn't realize.

would graphical input be allowed, or does it have to be text?

@smls You're indeed correct, fixed

@12Me21 Sorry, the input has to be a maze with the characters you see in the question. How you insert them however is up to you.

@TuukkaX As far as walking around the box is concerned, how does one avoid that? The I and U characters are outside of the box. If they should happen to be on the same side of the box, there is a direct path that does not enter the maze.

@MichaelVehrs The OP has stated (with a grammar error) "though the maze", so solutions not walking through the maze are disallowed.

Kevin, I don't know if you've missed my comment regarding the time and memory. What's your response?

@TuukkaX Shouldn't that be a test case, then?

@MichaelVehrs Sure. A one where U and I are adjacent, would be nice.

@TuukkaX I'll add a test case for I & U adjacent. Regarding the time/memory, if you can indeed prove it works then I guess it's fine, although I'm curious in what case it would work that long.

@KevinCruijssen For example, a solution that tests each combination of "v^<>" for a length up to the amount of empty boxes inside the maze. The right solution will be there, but takes astronomical time to compute.

Retina, 338 281 275 273 261 bytes
¶U
¶&
+`·(\w.+)$
|$1
((.)+I.+¶.+¶(?<-2>.)+)·
$1v
+`((.)*)\+(.).*(¶(?<-2>.)*.)((\w)|·)·?
$1$4$.4$3$6
·v
-v
G`1
·U
&
{`\B·\d+.(\w+)
$1K$&
(\w+)·\d+.\B
$&$1r
(?<=\D\2.(\w+).+?¶.*\D(\d+)[·&])\B
$1v
)`\D(\d+).\B(?=.+¶.*\D\1·(\w+))
$&$2A
^.+\d·(\w+)
&$1A
M!`&\w+
I|&

Try it online!

Notes

Due to significant whitespaces, all spaces (0x20) are replaced with interpunct (·) both in this answer and the TIO link. The program works fine if the spaces are restored.
Uses AvKr for up, down, left, and right, respectively. Those can be replaced with any letters except I.
Takes about 40s on TIO for the 15×15 test case. Be patient. Reworked the part for finding the shortest path once the path reached the exit. Turns out that was taking a lot of time.
Could completely break on mazes that are 66 or more cells wide but can handle mazes of arbitrary height. A fix for arbitrary width takes +1 byte.

Explanation
The program consists of 3 phases:

A construction phase to convert the maze to a compact format that is easier to work with (detailed below).
A fill phase to actually solve the maze using a flood fill algorithm.
A return phase to return the shortest path at the exit.

Format
Since the original maze format is quite unwieldy, the first part of the program converts it into a different format.
Cells
In the original format, each cell is represented as a 2×3 region:
+               <top wall>      <top wall>
<left wall>     <data/space>    <space>

Since the right column contains no information, the program identifies cells as any 2×2 region with a + at the top-left.
This leaves us with 3 kinds of cells:

I Cells: Cells that are properly inside the maze.
R Cells: Cells that are to the right of the maze. These are created by the padding used to house the entrance or exit. For example, the exit U in test case 1 is in an R-Cell.
B Cells: Cells that are below the maze. Like R-Cells, these are created by padding.

In the new format, cells are represented as a variable-length string:
<left wall> <column number> <top wall/exit marker> <path>

The left and top wall are copied from the original format. The column number is based on the horizontal position of the cell and is used for alignment (identifying cells directly on top of/beneath each other). Path is an alphabetical string used during the fill phase to save the shortest path to reach that cell. Path and exit marker will be further explained.
Half-cells
Although most of the maze are cells, there are regions of the maze that are not cells:

R Half-cells: If there is no right padding, the +s along the right wall does not form cells since they are on the last column.
L Half-cells: If there is left padding, cells cannot form there since there are no + to the left of them. For example, the entrance I in test case 1 is in an L Half-cell.

Technically, there are T half-cells above the maze (when there is top padding) and B half-cells (along the bottom wall when there is no bottom padding) but they are not represented in the new format.
The top row of a half-cell would be removed as part of constructing full cells in the same row, so half-cells are represented in the new format as
<wall/exit marker>? <path>

An R Half-cells is just |. An L Half-cells has just I as the path, just the exit marker and an empty path, or just an empty wall.
Entrances and exits
If the entrance is to the left, right or bottom of the maze, then the entrance marker I would naturally be included in the (half-)cell as the path, which can be removed when returning the final path.
If the entrance is above the maze, the first (downward) step is taken during the construction phase since T half-cells are removed during construction. This keeps a workable path in a full cell. The top wall is closed afterwards.
If the exit is to the left, right or bottom of the maze, then U would naturally be included in the (half-)cell. To avoid being mistaken as a path, the non-alphanum exit marker & is used instead of U. The exit marker is embedded into a cell or half-cell (as specified above).
If the exit is above the maze, then it would be the only hole that can go above the top row of cells (since the one for the entrance, if present, would be closed already). Any path reaching that hole can exit the maze by taking an upward step.
Lastly, any B Cell containing the entrance or exit must close its left wall to prevent "solving" the maze by walking along the B Cells. Entrances and exits in R Cells or L Half-cells need no further processing since the flood fill algorithm does not permit vertical movements to/from them.
Example
As an example, the first test case
·+--+--+--+--+--+--+--+--+--+--+·
I···············|·····|········|·
·+··+--+--+--+··+··+··+··+--+··+·
·|···········|·····|··|··|·····|·
·+--+--+--+··+--+--+··+··+··+--+·
·|···········|·····|·····|·····|·
·+··+--+--+··+··+--+--+··+--+··+·
·|·····|·····|·····|·····|·····|·
·+--+··+··+--+--+··+--+--+··+··+·
·|·····|········|········|··|··|·
·+··+--+--+--+··+--+--+··+··+··+·
·|·····|·····|·····|········|··|·
·+--+··+··+--+--+··+--+--+--+--+·
·|··|··|·················|·····|·
·+··+··+--+--+--+··+--+··+··+··+·
·|·····|········|··|··|··|··|··|·
·+--+--+··+··+--+··+··+··+--+··+·
·|········|·····|·····|··|·····|·
·+··+--+--+--+··+··+··+··+··+--+·
·|···········|·····|··|·········U
·+--+--+--+--+--+--+--+--+--+--+·

is
I·3-·6-·9-·12-·15-|18-·21-|24-·27-·30-|33·
·|3··6-·9-·12-|15··18·|21·|24·|27-·30·|33·
·|3-·6-·9-·12·|15-·18-|21··24·|27··30-|33·
·|3··6-|9-·12·|15··18-|21-·24·|27-·30·|33·
·|3-·6·|9··12-·15-|18··21-·24-|27·|30·|33·
·|3··6-|9-·12-|15··18-|21-·24··27·|30·|33·
·|3-|6·|9··12-·15-·18··21-·24-|27-·30-|33·
·|3··6·|9-·12-·15-|18·|21-|24·|27·|30·|33·
·|3-·6-·9·|12··15-|18··21·|24·|27-·30·|33·
·|3··6-·9-·12-|15··18·|21·|24··27··30-·33&

in the new format. You can convert other mazes here.

Construction phase
The construction phase makes up the first 13 lines of the program.
¶U
¶&

Converts exit in L Half-cell to exit marker
+`·(\w.+)$
|$1

Adds walls to the left of entrance and exit in B Cells
((.)+I.+¶.+¶(?<-2>.)+)·
$1v

Takes the first step if entrance is above the maze
+`((.)*)\+(.).*(¶(?<-2>.)*.)((\w)|·)·?
$1$4$.4$3$6

Performs the actual conversion
·v
-v

Closes the top-entrance hole
G`1

Keeps only lines with a 1. Since mazes are at least 5 cells wide and column numbers occurs at increments of 3, a line with new-format cells must have a contain a column number between 10 and 19.
·U
&

Converts exit in R Cell or B Cell to exit marker

Fill phase
The fill phase makes up the next 8 lines of the program. It uses a flood fill algorithm to fill all cells with the shortest path to reach there from the entrance.
{`

Puts the whole fill phase on a loop to fill the whole maze.
\B·\d+.(\w+)
$1K$&

Each cell able to move left does so. A cell is able to move left if

it has a non-empty path
it has an empty left wall; and
the cell or L half-cell to its left has an empty path

(\w+)·\d+.\B
$&$1r

Then, each cell able to move right does so. A cell is able to move right if

it has a non-empty path
the cell to its right has an empty left wall; and
the cell to its right has an empty path

(?<=\D\2.(\w+).+?¶.*\D(\d+)[·&])\B
$1v

Then, each cell able to move down does so. A cell is able to move down if

it has a non-empty path
it has at least one cell or half-cell to its right (i.e. it is not an R Cell)
the cell below it (i.e. the cell on the next line with the same column number) has an empty top wall or has the exit marker; and
the cell below it has an empty path

Note that L Half-cells cannot move down since they don't have column numbers.
\D(\d+).\B(?=.+¶.*\D\1·(\w+))
$&$2A

Then, each cell able to move up does so. A cell is able to move up if

it has a non-empty path
it has an empty top wall
the cell above it has at least one cell or half-cell to its right; and
the cell above it has an empty path

Return phase
The return phase makes up the last 5 lines of the program. This phase searches for and returns the path filled into the exit cell.
The pattern of the path at the exit depends on where the exit is:

If the exit is in an L Half-cell, then that half-cell would be & <path>
If the exit is in an R Cell or B Cell, then that cell would be <left wall> <column number> & <path>
If the exit is in a T Half-cell, then as noted above, the the I Cell leading to the exit would be <left wall> <column number> · <path> and on the top row.

^.+\d·(\w+)
&$1A

Finds a cell on the top line with an empty top wall and a non-empty path. This takes care of the last case by adding the last step and the exit marker.
M!`&\w+

Matches and returns a non-empty path following an exit marker.
I|&

Removes the exit marker and the I prefix of the path.

Why the AvKr? Do they have a meaning / are they abbreviations for up, down, left, and right in your native language, or is there another reason why you've chose those specific characters?

@KevinCruijssen Simply because I must use alphanumeric characters and AvKr are the closest thing to arrows in alphanum.

Perl 6, 259 295 bytes
{my \a=S:g/(.)$0+/{$0 x($/.comb+.5)*2/3}/;sub f (\c,\v,*@p) {with (c ne any v)&&a.lines».comb[+c[0];+c[1]] ->$_ {for (/\s/??10011221!!/I/??a~~/^\N*I|I\N*$/??2101!!1012!!'').comb X-1 {f [c Z+$^a,$^b],(|v,c),@p,chr 8592+$++}
take @p if /U/}}
[~] (gather f a~~/(\N+\n)*(.)*I/,[]).min(+*)[1,3...*]}

How it works

my \a = S:g/ (.) $0+ /{ $0 x ($/.chars + .5) * 2/3 }/;

This squeezes the maze so that the inside of each cell is 1x1 instead of 2x1 space characters:
 +--+--+--+--+--+             +-+-+-+-+-+
I   |        |  |            I  |     | |
 +  +--+--+  +  +             + +-+-+ + +
 |        |  |  |             |     | | |
 +  +--+  +  +  +             + +-+ + + +
 |  |  |     |  |     -->     | | |   | |
 +  +  +--+  +  +             + + +-+ + +
 |        |     |             |     |   |
 +--+  +  +--+--+             +-+ + +-+-+
 |     |         U            |   |      U
 +--+--+--+--+--+             +-+-+-+-+-+

sub f (\c,\v,*@p) {
    with (c ne any v) &&                   # If the coordinate wasn't visited yet
         lines».comb[+c[0];+c[1]] -> $_ {  # and a character exists there...
        for (                          # For each vector...
             /\s/ ?? 10011221 !!       #  from a cell: (0,-1), (-1,0), (0,1), (1,0)
             /I/  ?? a~~/^\N*I|I\N*$/
                      ?? 2101          #  from a top/bottom entrance: (1,0), (-1,0)
                      !! 1012          #  from a left/right entrance: (0,-1), (0,1)
                  !! ''                #  otherwise: none
            ).comb X-1 {
            f                       #   Recurse with arguments:
                [c Z+ $^a, $^b],    #     c plus the vector
                (|v, c),            #     v with c appended
                @p, chr 8592 + $++  #     p with the correct Unicode arrow appended
        }
        take @p if /U/
    }
}

This is the recursive path-finding function. It takes three parameters: The current coordinate c=(y,x), the list of already visited coordinates v, and the path p taken so far (as a list of arrow characters).
If the character at the current coordinate is a space, it recurses to its four neighbors.
If the character at the current coordinate is a I, it recurses to the two neighbors that aren't "along the edge", to force solutions to go through the maze and not around it.
If the character at the current coordinate is a U, it calls take on the accumulated path string.

[~] (gather f a ~~ /(\N+\n)*(.)*I/, []).min(+*)[1,3...*]

The recursive function is initially called with the coordinate of the letter I, which is found using a regex.
The gather keyword collects all values on which take was called inside the function, i.e. all valid non-cyclical paths through the maze.
The shortest path is chosen, every second arrow is dropped to account for the fact that two identical moves are required to get from one cell to the next, and the remaining arrows are concatenated to form the string that is returned from the lambda.

First of all great job on being the first to complete my challenge! :) Smart how you've changed the two spaces to one to ease the actual movement/counting. +1 from me. Anyway, after some comments two new test cases were added. Could you verify these work with your solution as well? (Also, does Perl 6 have a TIO or other online compiler that you could add a link to?)

@KevinCruijssen: It went around the maze in the new test-cases. :( I fixed the code now. tio.run supports Perl 6, but for some reason, this doesn't work there... maybe it has a too old Perl 6 version?

Great job fixing the code. Sorry for specifying the rule of having to go through the maze after you've already posted your answer, but chapeau for fixing it so fast. And regarding the TIO version I have no idea. Not really my expertise..

Since you were the first to answer my challenge four months ago, I gave the bounty to you. :) And the Accept is for the slightly shorter Retina answer.

Python 2: 302 bytes
from re import*
r=lambda x:[''.join(_)for _ in zip(*x)][::-1]
z=',l)for l in s]'
def f(s,b=1,o=0,n=0):
 exec("s=[sub('(..).(?!$)',r'\\1'%s;"%z+"s=r([sub(' I ','+I+'%s);"%z*4)*b+"t=[sub('I  ','@@I'"+z
 if'I U'in`s`or n>3:return`o%4`+n/4*`s`
 return min(`o%4`+f(t,0,o,4*(t==s)),f(r(s),0,o+1,n+1),key=len)

Takes input as an array of strings all with the same length. Prints 0 for right, 1 for down, 2 for left, and 3 for up.
Explanation
I took a different approach than the other answers. General idea: recursively search by finding the shortest path between going straight forward and rotating the board 90 degrees.
from re import*
r=lambda x:[''.join(_)for _ in zip(*x)][::-1] #Rotates the board counterclockwise
z=',l)for l in s]'    #Suffix for hacky exec golfing
def f(s,b=1,o=0,n=0): #b is 1 on initial call, 0 on every recursion
                      #o is orientation
                      #n is number of rotations
 exec("s=[sub('(..).(?!$)',r'\\1'%s;"%z  #Squeeze the maze
      +"s=r([sub(' I ','+I+'%s);"%z*4)   #Add walls around the I to keep it in the maze
      *b                                 #Only if b is 1
      +"t=[sub('I  ','@@I'"+z            #Attempt to move right

 if'I U'in`s`or n>3:return`o%4`+n/4*`s`  #If the I is next to the U, return the orientation
                                         #If there were 4 rotations, return a long string
 return min(                             #Return the path with the shortest length:
            `o%4`+f(t,0,o,4*(t==s)),       #Moving forward if possible
            f(r(s),0,o+1,n+1),             #Rotating the board
        key=len)

Try it online!

Welcome to PPCG! This is a great first answer, and I'm impressed you decided to do a pretty tough challenge as your first. Also smart how you've put walls around the I to prevent the path from going outside the maze. Enjoy your stay, and +1 from me. :)

JavaScript (ES6), 356 bytes
a=>(a=a.map(s=>s.filter((_,i)=>!i|i%3)),g=([x,y])=>a[y]&&a[y][x],o=[],c=([x,y],m="",v=[])=>[[0,1],[1,0],[0,-1],[-1,0]].map(([j,k],i)=>(p=[x+j,y+k],!m&(!y|y>a[l="length"]-2)==i%2|v.includes(""+p)||(g(p)<"!"?c(p,m+"v>^<"[i],[...v,""+p]):g(p)=="U"?o.push(m.replace(/(.)\1/g,"$1")):0))),a.map((h,i)=>h.map((k,j)=>k=="I"&&c([j,i]))),o.sort((a,b)=>a[l]-b[l])[0])

Takes input as a 2D array of characters. Each line must be left-padded by one space and have no trailing space, no matter where the start/end points are.
Uses smls's idea of squishing the maze to make each cell 1x1 and removing repeated arrows from the output.
Ungolfed and Explained
a=>(
    a=a.map(s=>s.filter((_,i)=>!i|i%3)),    // squish the maze to 1x1 cells
    g=([x,y])=>a[y]&&a[y][x],               // helper func to get maze value
    o=[],                                   // resulting movesets
    c=([x,y], m="", v=[]) =>                // recursive func to search
                                            // takes current point, moves, and visited spots
        [[0,1],[1,0],[0,-1],[-1,0]].map(([j,k],i)=>(// for each direction
            p=[x+j,y+k],
            !m & (!y | y>a[l="length"]-2) == i%2 |  // if first move, prevent moving out of maze
                v.includes(""+p) || (               // also prevent if already visited
                    g(p)<"!" ?                      // is this a space?
                        c(p, m+"v>^<"[i], [...v,""+p]) // check this spot recursively
                    : g(p)=="U" ?                   // if this the end?
                        o.push(                     // add moves to moveset
                            m.replace(/(.)\1/g,"$1")) // with double arrows removed
                    : 0
                )
        )),

    a.map((h,i)=>h.map((k,j)=>      // find the starting "I" and
        k=="I" && c([j,i])          // begin recursion at that point
    )),

    o.sort((a,b)=>a[l]-b[l])[0]     // get shortest path
)

Test Snippet

f=
a=>(a=a.map(s=>s.filter((_,i)=>!i|i%3)),g=([x,y])=>a[y]&&a[y][x],o=[],c=([x,y],m="",v=[])=>[[0,1],[1,0],[0,-1],[-1,0]].map(([j,k],i)=>(p=[x+j,y+k],!m&(!y|y>a[l="length"]-2)==i%2|v.includes(""+p)||(g(p)<"!"?c(p,m+"v>^<"[i],[...v,""+p]):g(p)=="U"?o.push(m.replace(/(.)\1/g,"$1")):0))),a.map((h,i)=>h.map((k,j)=>k=="I"&&c([j,i]))),o.sort((a,b)=>a[l]-b[l])[0])

let tests = [" +--+--+--+--+--+--+--+--+--+--+\nI               |     |        |\n +  +--+--+--+  +  +  +  +--+  +\n |           |     |  |  |     |\n +--+--+--+  +--+--+  +  +  +--+\n |           |     |     |     |\n +  +--+--+  +  +--+--+  +--+  +\n |     |     |     |     |     |\n +--+  +  +--+--+  +--+--+  +  +\n |     |        |        |  |  |\n +  +--+--+--+  +--+--+  +  +  +\n |     |     |     |        |  |\n +--+  +  +--+--+  +--+--+--+--+\n |  |  |                 |     |\n +  +  +--+--+--+  +--+  +  +  +\n |     |        |  |  |  |  |  |\n +--+--+  +  +--+  +  +  +--+  +\n |        |     |     |  |     |\n +  +--+--+--+  +  +  +  +  +--+\n |           |     |  |         U\n +--+--+--+--+--+--+--+--+--+--+"," +--+--+--+--+--+\nI   |        |  |\n +  +--+--+  +  +\n |        |  |  |\n +  +--+  +  +  +\n |  |  |     |  |\n +  +  +--+  +  +\n |        |     |\n +--+  +  +--+--+\n |     |         U\n +--+--+--+--+--+"," +--+--+--+--+--+\nU      |        |\n +  +  +--+--+  +\n |  |     |     |\n +--+--+  +  +--+\n |        |     |\n +  +--+--+--+  +\n |  |     |     |\n +  +  +  +  +--+\n |     |         I\n +--+--+--+--+--+"," +--+--+--+--+--+\nU      |        |\n +  +  +--+--+  +\n |  |           |\n +--+--+  +  +--+\n |        |     |\n +  +--+--+--+  +\n |  |     |     |\n +  +  +  +  +--+\n |     |         I\n +--+--+--+--+--+","                                I\n +--+--+--+--+--+--+--+--+--+--+  +--+--+--+--+\n |     |              |                    |  |\n +  +  +  +--+--+--+  +  +--+--+  +--+--+  +  +\n |  |     |        |     |        |     |     |\n +--+--+--+  +--+  +  +--+--+--+--+  +--+--+--+\n |     |  |  |  |     |     |           |     |\n +  +  +  +  +  +--+  +  +  +  +--+--+  +--+  +\n |  |        |        |  |     |        |     |\n +  +--+--+--+  +--+--+  +  +--+  +--+--+  +--+\n |  |     |     |        |  |     |     |     |\n +  +--+  +  +--+  +--+--+  +--+--+  +  +--+  +\n |  |     |        |     |           |        |\n +  +  +--+--+--+--+  +  +--+--+--+  +--+  +--+\n |     |     |        |        |  |     |     |\n +--+--+--+  +  +--+--+  +--+  +  +--+  +--+  +\n |              |     |     |        |  |  |  |\n +  +--+--+--+--+  +  +  +--+--+--+  +  +  +  +\n |     |  |     |  |  |        |        |  |  |\n +--+  +  +  +  +  +  +--+--+  +  +  +--+  +  +\n |     |     |  |  |  |           |  |     |  |\n +--+  +--+--+  +  +  +  +--+--+--+  +  +  +  +\n |     |        |  |  |     |        |  |  |  |\n +  +--+  +--+--+  +  +--+--+  +  +--+  +  +  +\n |        |     |  |     |     |  |     |  |  |\n +--+--+--+  +  +  +--+  +  +--+--+  +--+  +  +\n |  |        |        |     |        |     |  |\n +  +  +--+--+--+--+  +--+--+  +--+--+  +--+  +\n |  |              |              |     |     |\n +  +  +  +--+--+--+--+--+--+--+--+  +--+  +--+\n |     |                                |     |\n +--+--+--+--+--+--+--+--+--+  +--+--+--+--+--+\n                             U"," +--+--+--+--+--+\nI               |\n +  +  +  +  +  +\n |              |\n +  +  +  +  +  +\n |              |\n +  +  +  +  +  +\n |              |\n +  +  +  +  +  +\n |               U\n +--+--+--+--+--+","  I  U\n +  +  +--+--+--+\n |  |        |  |\n +  +--+--+  +  +\n |     |     |  |\n +--+  +  +--+  +\n |        |  |  |\n +  +--+  +  +  +\n |     |        |\n +--+  +--+--+  +\n |     |        |\n +--+--+--+--+--+"," +--+--+--+--+--+\n |     |        |\n +  +--+  +--+  +\nI   |     |  |  |\n +  +  +--+  +  +\nU   |     |  |  |\n +--+--+  +  +  +\n |     |     |  |\n +  +--+--+--+  +\n |               \n +--+--+--+--+--+"];
S.innerHTML="<option>Tests"+Array(tests.length).fill().map((_,i)=>"<option>"+(i+1)).join``;
<select id=S oninput="I.value=S.selectedIndex?tests[S.value-1]:''"></select><br>
<textarea id=I rows=20 cols=50></textarea><br><button onclick="O.innerHTML=f(I.value.split`\n`.map(x=>[...x]))">Run</button>
<pre id=O>

Retina, 416 bytes
T` `+`^.*| ?¶.|.*$
I
#
{+` (\w)
d$1
+`(\w)
$1a
+`(¶(.)*) (.*¶(?<-2>.)*(?(2)(?!))\w)
$1s$3
}+m`(^(.)*\w.*¶(?<-2>.)*(?(2)(?!)))
$1w
^
w¶
w((.|¶)*(¶(.)*#.*¶(?<-4>.)*(?(4)(?!))(s)|#(d)|(a)#))
$4$5$6¶$1
{`^(.*d)(¶(.|¶)*)#(\w)
$1$4$2 #
^(.*a)(¶(.|¶)*)(\w)#
$1$4$2#
^(.*s)(¶(.|¶)*¶(.)*)#(.*¶(?<-4>.)*(?(4)(?!)))(\w)
$1$6$2 $5#
}`^(.*w)(¶(.|¶)*¶(.)*)(\w)(.*¶(?<-4>.)*(?(4)(?!)))#
$1$5$2#$6
s`U.*

(a|d)\1\1?
$1
ss
s
ww
w

Try it online! Had I seen this question when it was originally posted, this is probably the answer I would have given, so I'm posting it anyway, even though there's a much better answer in Retina. Explanation:
T` `+`^.*| ?¶.|.*$

Fill in the border. This avoids walking around the outside of the maze (e.g. for test case 7).
I
#

Place a non-alphabetic marker at the entrance.
{+` (\w)
d$1
+`(\w)
$1a
+`(¶(.)*) (.*¶(?<-2>.)*(?(2)(?!))\w)
$1s$3
}+m`(^(.)*\w.*¶(?<-2>.)*(?(2)(?!)))
$1w

Flood fill from the exit to the entrance. At each step, use a letter to indicate the best direction to go (wasd - this might be familiar to gamers; I had also considered hjkl but I found it too confusing). Additionally, prefer to repeat the same direction; this avoids going left/right in between two vertically adjacent cells.
^
w¶

Assume the first step is down.
w((.|¶)*(¶(.)*#.*¶(?<-4>.)*(?(4)(?!))(s)|#(d)|(a)#))
$4$5$6¶$1

But if there's a letter above, left or right of the entrance, change that to the first step.
{`^(.*d)(¶(.|¶)*)#(\w)
$1$4$2 #
^(.*a)(¶(.|¶)*)(\w)#
$1$4$2#
^(.*s)(¶(.|¶)*¶(.)*)#(.*¶(?<-4>.)*(?(4)(?!)))(\w)
$1$6$2 $5#
}`^(.*w)(¶(.|¶)*¶(.)*)(\w)(.*¶(?<-4>.)*(?(4)(?!)))#
$1$5$2#$6

Move the marker in the direction of the last move, reading the direction of the next move from the square that the marker is moving to, and add that to the list of directions. This repeats until the U is reached.
s`U.*

Delete everything after the directions as it's not needed any more.
(a|d)\1\1?
$1
ss
s
ww
w

The original grid is on a 3×2 layout. While moving vertically if we zig-zag horizontally the flood fill will optimise the movement and only move 3n-1 characters horizontally, so when dividing by three, we need to round up. Vertically we just divide by 2.
I also investigated a true square grid solution i.e where the character matrix is itself square rather than being a 3×2 layout with an optional border. While probably nonconforming to the question, the ability to transpose reduced the byte count to 350: Try it online!

Nice answer, +1! I do see in your TIO link you've added two - around both the entrance and exit characters. Since the challenge is mainly about going through the maze I guess it's fine, but I'm curious: what were the issues when you hadn't placed those walls above/below the I and U? Also, could you verify this works for test case 7 with the I and U at the top instead of sides? TIO exceeds the 60 second limit, so I'm unable to test it myself. Although reading your explanation of first trying to go down by default, I assume it should work fine.

@KevinCruijssen The "secondary" answer works for test case 7 but requires extra characters: Try it online! continued...

@KevinCruijssen The "main" answer had a bug whereby it couldn't cope with the exit on the top line at all. It also has a similar bug to the "secondary" answer whereby it prefers to walk around the outside of the maze if it can. (Also, I didn't get anywhere near the 60 second limit.)

Actually, I could fix both answers by filling in the border. I'll do that later when I have time.


text:
Determine the type of Cuboid
Introduction:
I'm a twisty puzzles collector. Here you can see my current collection of ± 300 puzzles.
I think everyone knows the regular Rubik's Cube (3x3x3 Cube), which is a NxNxN Cube. There are also Cuboids (block-shaped puzzles), which come in different forms, perhaps better explained by SuperAntionioVivaldi here:

Regular Domino Cuboids (like the 2x2x3; 2x3x3; 3x3x4; etc.) - They come in the form of NxNx(N+O) or Nx(N+O)x(N+O), which have either two odd dimensions and an even, or two even and an odd.
Shapeshifter Cuboids (like the 2x2x4; 3x3x5; 3x3x9; 4x4x6; etc.) - They come in the form of NxNx(N+P), which as the name suggests, shapeshifts (in all directions). All three dimensions are either odd or even.
Floppy Cuboids (like the 1x3x3; 2x4x4; etc.) - They come in the form of Nx(N+P)x(N+P), which are almost the same as the Shapeshifters, but with so-called Floppy Parities.
Brick Cuboids (like the 2x3x4; 3x4x5; 2x3x5; etc.) - They come in the form of Nx(N+O)x(N+P), which just like the Regular Domino Cuboids have either two odd dimensions and an even, or two even and an odd; but don't have any of the same dimensions.
Ultimate Shapeshifters (like the 2x4x6; 3x5x7; 2x4x10; etc.) - They come in the form of Nx(N+O)x(N+R), and shapeshift in any direction. All three dimensions are either odd or even; but don't have any of the same dimensions.

Challenge:
Input:
A positive integer n with the following restriction: 8 <= n <= 125.
n can be uniquely decoded as the product of three values (the dimensions), of which each is between 2 and 5 inclusive.
The reason I've restricted it to 2-5 is to prevent duplicated inputs (like 1x2x4 = 8 and 2x2x2 = 8), even though there are many lower/higher order Cuboids out there. This also means there are no test cases for Ultimate Shapeshifters.
Output / Test cases:
These are all the cases your program/function should support, ranging from edge lengths 2 through 5 in every possible three-dimensional configuration:
Input   Cuboid/Cube   Type/Output
8       2x2x2         Cube
12      2x2x3         Regular Domino Cuboid
16      2x2x4         Shapeshifter Cuboid
20      2x2x5         Regular Domino Cuboid
18      2x3x3         Regular Domino Cuboid
24      2x3x4         Brick Cuboid
30      2x3x5         Brick Cuboid
32      2x4x4         Floppy Cuboid
40      2x4x5         Brick Cuboid
50      2x5x5         Regular Domino Cuboid
27      3x3x3         Cube
36      3x3x4         Regular Domino Cuboid
45      3x3x5         Shapeshifter Cuboid
48      3x4x4         Regular Domino Cuboid
60      3x4x5         Brick Cuboid
75      3x5x5         Floppy Cuboid
64      4x4x4         Cube
80      4x4x5         Regular Domino Cuboid
100     4x5x5         Regular Domino Cuboid
125     5x5x5         Cube

Challenge rules:

Any non-Cube/non-Cuboid input within the 8-125 range should result in 'none' as output.
The output format is your own choice. I think the most reasonable is integers, like 0 = 'none'; 1 = Cube; 2 = Regular Domino Cuboid; 3 = Shapeshifter Cuboid; 4 = Floppy Cuboid; 5 = Brick Cuboid. Any other output format is also fine, as long as you specify which one you've used.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters, full programs. Your call.
Default Loopholes are forbidden. (NOTE: Since I don't know if there is a smart formula for the input-to-output conversion, it is allowed to hardcode the answers based on the input.)
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.

Been in the sandbox since October 2016.

There is no helicopter cube in your collection?

@GB Nope. I do have a Curvy Copter, Curvy Copter Plus, Curvy Copter III, Curvy Chop Cube, Helicopter Dodecahedron and custom-made Super Truncated Curvy Copter III, but no Helicopter Cube. :) It's a bit too similar to the Curvy Copter, but I might get it some day.

Is the input sorted? or do we have to sort manually?

@MatthewRoh The input is a single integer (i.e. 24), so I don't know what you want to sort about it?

Oh. Nevermind. I didnt see that part.

05AB1E, 26 21 bytes
None: 0
 Cube: 1
 Regular Domino Cuboid: 2
 Shapeshifter Cuboid: 3
 Brick Cuboid: 4
 Floppy Cuboid: 5
•S3X@I¨%÷'•5L¦3ãPÙIkè

Try it online!
or as a Test suite
Explanation
•S3X@I¨%÷'•            # push base-214 compression of the number 123224454212324512210
           5L¦         # push the list [2,3,4,5]
              3ã       # cartesian product with repetion of size 3
                P      # product of each sublist
                 Ù     # remove duplicates
                  Ik   # get the index of input in that list (-1 if non-existant)
                    è  # get the element at this index in the above number

The only place I see that we could save bytes here is find a better way of generating the number 123224454212324512210.
It is only 1-off from a prime, so one possible save would be to find the index of that prime and generate the index in less than 9 bytes.
I don't know how well the pi-function works for 21-digit primes but that could be a possibility.

Nice, I'm curious for that explanation to see what formula/quirk/pattern you've used to determine the Cube/Cuboid. +1

@KevinCruijssen: I might be able to save a byte or two still. I'll add the explanation after I've given that a try. I have a prime I want to find the order of (but I haven't found anything online to help me with that and I'm at work so I don't really have time to implement something myself :)

@Emigna jeebus creezy, how long has k existed?!!??!?!?!?!

@carusocomputing Since December 30, 2015.

JavaScript (ES6), 97 92 86 bytes
This function first checks the validity of the input, then picks the correct value from a lookup table.
Surprisingly, the longest part is the validity check (is n of the form x*y*z with x, y and z in [2,3,4,5]?). There must be a shorter way of doing it, but I couldn't figure it out so far.
n=>'NBBF..CRCC.BRR..SFRRRRR.B..C'[[34707324,0x80000800,4240,262208][n&3]>>n/4&1&&n%29]

Returns a character:

N: None
C: Cube
R: Regular Domino Cuboid
S: Shapeshifter Cuboid
B: Brick Cuboid
F: Floppy Cuboid

Test

let f =

n=>'NBBF..CRCC.BRR..SFRRRRR.B..C'[[34707324,0x80000800,4240,262208][n&3]>>n/4&1&&n%29]

// invalid
;[9,13,99].map(
  n => { console.log(n, f(n)) }
)

// valid
;[8,12,16,20,18,24,30,32,40,50,27,36,45,48,60,75,64,80,100,125].map(
  n => { console.log(n, f(n)) }
)

Perl 6, 69 58 bytes
{%(unique([X*] (2..5)xx 3)Z=>:32<AM0K21IHN61H5>.comb){$_}}

Uses the integer output format suggested in the task description, except that it returns the uninitialized value (Any) instead of 0 in case of inputs that don't form a valid cube/cuboid.
How it works

unique([X*] (2..5)xx 3)
Generates the list 8 12 16 20 18 24 30 32 40 50 27 36 45 48 60 75 64 80 100 125.
:32<AM0K21IHN61H5>.comb
Generates the list 1 2 3 2 2 5 5 4 5 2 1 2 3 2 5 4 1 2 2 1 (from a base-32 literal).
%(   Z=>   )
Generates a Hash (associative map) with the first list as the keys, and the second list as the values.
   {$_}
Indexes the Hash with the input number..

Heh, I see now that I've used the same approach as @Emigna's 05AB1E answer. But I came up with it independently, honest! :)

Ruby, 106 98 96 bytes
->n{[[x=25,2421],[15,53],[9,21],[4,1232504350200510002]].any?{|a,b|n%a<1&&x="00#{b}"[n/a]}?x:?0}

Because, why not, hardcoding.
As specified, 0 = 'none'; 1 = Cube; 2 = Regular Domino Cuboid; 3 = Shapeshifter Cuboid; 4 = Floppy Cuboid; 5 = Brick Cuboid

Batch, 163 bytes
@set/as=0,c=29948521
@for /l %%i in (2,1,5)do @for /l %%j in (%%i,1,5)do @for /l %%k in (%%j,1,5)do @set/as+=c%%6*!(%%i*%%j*%%k-%1),c/=6,c+=14081593*!c
@echo %s%

Uses the suggested output format. Explanation: The basic idea is to loop over the list of cubes as defined in the question. For each cube, we calculate to see if its volume is the input integer, and if so, calculate the type of cube from a lookup table.
The original lookup table was a string of letters, but doing string manipulation in a for loop is tricky, so I switched to digits which can be extracted arithmetically. Sadly Batch is limited to 32-bit integers so I couldn't fit all of the digits into a single variable (even in base 5 you can only get 13 digits) so instead I split the variable up into two parts, encoded in base 6 for convenience. 29948521 is 2545522321 in base 6 which encodes the 10 smallest cuboids in reverse order; when it runs out of digits we add 14081593 which is 1221452321 in base 6 encoding the 10 biggest cuboids.