text:
Visualize an Array
Given an array of any depth, draw its contents with borders of +-| around each subarray. Those are the ASCII characters for plus, minus, and vertical pipe.
For example, if the array is [1, 2, 3], draw
+-----+
|1 2 3|
+-----+

For a nested array such as [[1, 2, 3], [4, 5], [6, 7, 8]], draw
+-----------------+
|+-----+---+-----+|
||1 2 3|4 5|6 7 8||
|+-----+---+-----+|
+-----------------+

For a ragged array such as [[[1, 2, 3], [4, 5]], [6, 7, 8]], draw
+-------------------+
|+-----------+-----+|
||+-----+---+|6 7 8||
|||1 2 3|4 5||     ||
||+-----+---+|     ||
|+-----------+-----+|
+-------------------+

Notice that there is more space after drawing [6, 7, 8]. You may either draw the contents on the top-most, center, or bottom-most line, but whichever you choose, you must remain consistent.
This challenge was inspired by the box verb < from J.
Rules

This is code-golf so the shortest code wins.
Builtins that solve this are not allowed.
The input array will contain only nonnegative integer values or arrays. Each array will be homogenous, meaning that its elements will either by only arrays or only integers, but never a mix of both.
Each subarray may be nested to any depth.
The output may either by as a string or as an array of strings where each string is a line of output.

Test Cases
[]
++
||
++

[[], []]
+---+
|+++|
|||||
|+++|
+---+

[[], [1], [], [2], [], [3], []]
+-----------+
|++-++-++-++|
|||1||2||3|||
|++-++-++-++|
+-----------+

[[[[[0]]]]]
+---------+
|+-------+|
||+-----+||
|||+---+|||
||||+-+||||
|||||0|||||
||||+-+||||
|||+---+|||
||+-----+||
|+-------+|
+---------+

[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]
+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|+-------+|+---+|1||
|||+---------+|||+-----+|||2 1|| ||
||||+-------+|||||3 2 1|||+---+| ||
|||||4 3 2 1|||||+-----+||     | ||
||||+-------+|||+-------+|     | ||
|||+---------+||         |     | ||
||+-----------+|         |     | ||
|+-------------+---------+-----+-+|
+---------------------------------+

If my language has no nested arrays, can I disregard the definition of the data type?

@ThreeFx You could also take the input as a string representing the nested array

That is REALLY inefficient (in Haskell). I'd have to parse numbers manually and so on. In that case it would be shorter to define and use the datatype.

@ThreeFx Or you could pad the array with sentinel values such as -1 since I also limited the integers to be non-negative. Then would just have to clean the output for those invalid values.

Sorry about deleting the post I made, I need to fix it up because it wasn't working for one of the test cases.

So I guess J's builtin box type representation is disallowed?

@ConorO'Brien Yes, assuming the default is ascii representation, it completely trivializes the challenge so I had to ban builtins. Also, the sample cases were created in J

@miles yeah, I figured they were :)

Extending the bottom border of each inner box downward as much as possible so that the boxes are symmetric across horizontal axis through middle is not valid, I assume? Or would you allow it? I can show you an example if you want, but not now because on phone.

Would input format like (1 2 3) instead of [1, 2, 3] be acceptable?

Example of extending the boxes downward: http://chat.stackexchange.com/transcript/message/33239514#33239514

@MitchSchwartz Sure, take the input in a nested tuple or whatever format is native to your language. Your output is fine as long as you remain consistent. Integers can be drawn at the top, center, or bottom, and the boxes can be at the top, center, bottom, or stretched to fill out their space like in your example.

no test cases with multi-digit integers?

May I have a checkmark?

@Adám If you have time, could you add an explanation to your answer.

@miles Good enough?

@Adám That's great, thanks

Dyalog APL, 56 bytes
Thanks to ngn for helping removing about a third of the bytes.
{⍵≡∊⍵:⍉⍪⍉⍕⍵⋄(⊢,⊣/)⊃,/(1⊖('++','|'⍴⍨≢),'-'⍪⍣2↑)¨↓↑↓¨∇¨⍵}⊂

TryAPL
Define the function, then run each test case and compare to the built-in ]Display utility.

[1, 2, 3]

[[1, 2, 3], [4, 5], [6, 7, 8]]

[[[1, 2, 3], [4, 5]], [6, 7, 8]]

[]

[[], []]

[[], [1], [], [2], [], [3], []]

[[[[[0]]]]]

[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]
Explanation
Overall, this is an anonymous function {...} atop an enclose ⊂. The latter just adds another level of nesting prompting the former to add an outer frame.
The anonymous function with white-space (⋄ is the statement separator):
{
    ⍵ ≡ ∊⍵: ⍉ ⍪ ⍉ ⍕ ⍵
    (⊢ , ⊣/) ⊃ ,/ (1 ⊖ ('++' , '|' ⍴⍨ ≢) , '-' ⍪⍣2 ↑)¨ ↓ ↑ ↓¨ ∇¨ ⍵
}

Here it is again, but with separated utility functions:
CloseBox ← ⊢ , ⊣/
CreateVertical ← '++' , '|' ⍴⍨ ≢
AddHorizontals ← 1 ⊖ CreateVertical , '-' ⍪⍣2 ↑
{
    ⍵ ≡ ∊⍵: ⍉ ⍪ ⍉ ⍕ ⍵
    CloseBox ⊃ ,/ AddHorizontals¨ ↓ ↑ ↓¨ ∇¨ ⍵
}

Now let me explain each function:
CloseBox takes a table and returns the same table, but with the table's first column appended on the right of the table. Thus, given the 1-by-3 table XYZ, this function returns the 1-by-4 table XYZX, as follows:
 ⊢ the argument (lit. what is on the right)
 , prepended to
 ⊣/ the leftmost column (lit. the left-reduction of each row)
CreateVertical takes a table and returns the a string consisting of the characters which would fit |s on the sides of the table, but with two +s prepended to match two rows of -. Eventually the table will be cyclically rotated one row to get a single +---... row above and below. Thus, given any  three row table, this function returns ++|||, as follows:
 '++' , two pluses prepended to
 '|' ⍴⍨ a stile reshaped by
 ≢ the (rows') tally of the argument
AddHorizontals takes a list-of-lists, makes it into a table, adds two rows of -s on top, adds the corresponding left edge characters on the left, then rotates one row to the bottom, so that the table has a border on the top, left, and bottom. As follows:
 1 ⊖ rotate one row (the top row goes to the bottom) of
 CreateVertical , the string  ++|||... prepended (as a column) to
 '-' ⍪⍣2 minus added twice to the top of
 ↑ the argument transformed from list-of-lists to table
{The anonymous function}: If the argument is a simple (not nested) list, make it into a character table (thus, given the 3-element list 1 2 3, this function returns the visually identical 1-by-five character table 1 2 3). If the argument is not a simple list, ensure the elements are simple character tables; pad them to equal height; frame each on their top, bottom, and left; combine them; and finally take the very first column and add it on the right. As follows:
 { begin the definition of an anonymous function
  ⍵ ≡ ∊⍵: if the argument is identical to the flattened argument (i.e. it is a simple list), then:
   ⍉ transpose the
   ⍪ columnized
   ⍉ transposed
   ⍕ ⍵ stringified argument; else:
  CloseBox Add the leftmost column to the right of
  ⊃ ,/ the disclosed (because reduction encloses) concatenated-across
  AddHorizontals¨ add -s on top and bottom of each of
  ↓ ↑ ↓¨ the padded-to-equal-height* of
  ∇¨ ⍵  this anonymous function applied to each of the arguments
 } end the definition of the anonymous function
* Lit. make each table into a list-of-lists, combine the lists-of-lists (padding with empty strings to fill short rows) into a table, then split the table into a list of lists-of-lists

JavaScript (ES6), 223 203 bytes
f=(a,g=a=>a[0].map?`<${a.map(g).join`|`}>`:a.join` `,s=g([a]),r=[s],t=s.replace(/<[ -9|]*>|[ -9]/g,s=>s[1]?s.replace(/./g,c=>c>`9`?`+`:`-`):` `))=>t<`+`?r.join`\n`.replace(/<|>/g,`|`):f(a,g,t,[t,...r,t])

Port of @MitchSchwartz's Ruby solution. Previous version which worked by recursively wrapping the arrays (and therefore worked for arbitrary content, not just integers):
f=(...a)=>a[0]&&a[0].map?[s=`+${(a=a.map(a=>f(...a))).map(a=>a[0].replace(/./g,`-`)).join`+`}+`,...[...Array(Math.max(...a.map(a=>a.length)))].map((_,i)=>`|${a.map(a=>a[i]||a[0].replace(/./g,` `)).join`|`}|`),s]:[a.join` `]

Note: Although I'm using the spread operator in my argument list, to obtain the desired output, provide a single parameter of the original array rather then trying to spread the array; this has the effect of wrapping the output in the desired outer box. Sadly the outer box costs me 18 bytes, and space-separating the integers costs me 8 bytes, otherwise the following alternative visualisation would suffice for 197 bytes:
f=a=>a.map?[s=`+${(a=a.map(f)).map(a=>a[0].replace(/./g,`-`)).join`+`}+`,...[...Array(Math.max(0,...a.map(a=>a.length)))].map((_,i)=>`|${a.map(a=>a[i]||a[0].replace(/./g,` `)).join`|`}|`),s]:[``+a]

Does this handle empty arrays? I receive an error Cannot read property 'map' of undefined for empty arrays such as []. For [1,2,[]], the last subarray isn't displayed for me.

@miles Sorry, I'd forgotten to check out the test cases, and those now all work. You haven't specified the output for [1,2,[]] because your examples only show arrays containing either integers or arrays but not both.

Great. Also never mind that one, I didn't cover it in the test cases and the problem will be simpler (since yours is the only working entry so far) if each array is homogenous.

Brainfuck, 423 bytes
->>+>>,[[>+>+<<-]+++++[>--------<-]>[<+>-[[-]<-]]>[[-]<<[>>>>+<<<<<<-<[>-<-]>>>-
]<<<[-<<<<<<-<]>+>>>]<<<[>>+>>>>>+<<<<<<<-]>>>>>>>>>,]<<+[<<,++>[-[>++<,<+[--<<<
<<<<+]>]]<[-<+]->>>>[<++<<[>>>>>>>+<<<<<<<-]>>>-[<++>-[>>>>+<<<<<++<]<[<<]>]<[>>
+<<<<]>>>+>+>[<<<-<]<[<<]>>>>->+>[-[<-<-[-[<]<[<++<<]>]<[<++++<<]>]<[>+<-[.<<<,<
]<[<<]]>]<[-<<<<<]>>[-[<+>---[<<++>>+[--[-[<+++++++<++>>,]]]]]<+++[<+++++++++++>
-]<-.,>>]>>>>+>>>>]<<-]

Formatted with some comments:
->>+>>,
[
  [>+>+<<-]
  +++++[>--------<-]
  >
  [
    not open paren
    <+>-
    [
      not paren
      [-]<-
    ]
  ]
  >
  [
    paren
    [-]
    <<
    [
      close paren
      >>>>+<<<<
      <<-<[>-<-]>>>
      -
    ]
    <<<
    [
      open paren directly after close paren
      -<<<<<<-<
    ]
    >+>>>
  ]
  <<<[>>+>>>>>+<<<<<<<-]>>>
  >>>>>>,
]
<<+
[
  <<,++>
  [
    -
    [
      >++<
      ,<+[--<<<<<<<+]
      >
    ]
  ]
  <[-<+]
  ->>>>
  [
    <++<<[>>>>>>>+<<<<<<<-]>>>-
    [
      at or before border
      <++>-
      [
        before border
        >>>>+<<<<
        <++<
      ]
      <[<<]
      >
    ]
    <
    [
      after border
      >>+<<
      <<
    ]
    >>>+>+>
    [
      column with digit or space
      <<<-<
    ]
    <[<<]
    >>>>->+>
    [
      middle or bottom
      -
      [
        bottom
        <-<-
        [
          at or before border
          -
          [
            before border
            <
          ]
          <
          [
            at border
            <++<<
          ]
          >
        ]
        <
        [
          after border
          <++++<<
        ]
        >
      ]
      <
      [
        middle
        >+<
        -[.<<<,<]
        <[<<]
      ]
      >
    ]
    <[-<<<<<]
    >>
    [
      border char or space
      -
      [
        not space
        <+>---
        [
          not plus
          <<++>>
          +
          [
            --
            [
              -
              [
                pipe
                <+++++++<++>>,
              ]
            ]
          ]
        ]
      ]
      <+++[<+++++++++++>-]<-.,>>
    ]
    > >>>+>>>>
  ]
  <<-
]

Try it online.
Expects input formatted like (((((4 3 2 1))))(((3 2 1)))((2 1))(1)) with a trailing newline, and produces output of the form:
+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|+-------+|+---+| ||
|||+---------+|||+-----+|||   || ||
||||+-------+|||||     ||||   || ||
|||||4 3 2 1||||||3 2 1||||2 1||1||
||||+-------+|||||     ||||   || ||
|||+---------+|||+-----+|||   || ||
||+-----------+|+-------+|+---+| ||
|+-------------+---------+-----+-+|
+---------------------------------+

The basic idea is to calculate which character to print based on the depth of nesting. The output format is such that the row index of a box's top border is equal to the corresponding array's depth, with symmetry across the middle row.
The tape is divided into 7-cell nodes, with each node representing a column in the output.
The first loop consumes the input and initializes the nodes, keeping track of depth and whether the column corresponds to a parenthesis (i.e., whether the column contains a vertical border), and collapsing occurrences of )( into single nodes.
The next loop outputs one row per iteration. Within this loop, another loop traverses the nodes and prints one character per iteration; this is where most of the work takes place.
During the initialization loop, the memory layout of a node at the beginning of an iteration is
x d 0 c 0 0 0
where x is a boolean flag for whether the previous char was a closing parenthesis, d is depth (plus one), and c is the current character.
During the character printing loop, the memory layout of a node at the beginning of an iteration is
0 0 d1 d2 c p y
where d1 indicates depth compared with row index for top half; d2 is similar to d1 but for bottom half; c is the input character for that column if digit or space, otherwise zero; p indicates phase, i.e. top half, middle, or bottom half; and y is a flag that gets propagated from left to right, keeping track of whether we have reached the middle row yet. Note that since y becomes zero after processing a node, we can use the y cell of the previous node to gain more working space.
This setup allows us to avoid explicitly calculating the max depth during the initialization phase; the y flag is back-propagated to update the p cells accordingly.
There is a -1 cell to the left of the nodes to facilitate navigation, and there is a cell to the right of the nodes that keeps track of whether we have printed the last row yet.

Ruby, 104 bytes
->s{r=s=s.gsub'}{',?|
r=[s,r,s]*$/while s=s.tr('!-9',' ').gsub!(/{[ |]*}/){$&.tr' -}','-+'}
r.tr'{}',?|}

Anonymous function that expects a string. For example, {{{{{4 3 2 1}}}}{{{3 2 1}}}{{2 1}}{1}} produces
+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|         |     | ||
|||+---------+||+-------+|     | ||
||||+-------+||||+-----+||+---+| ||
|||||4 3 2 1||||||3 2 1||||2 1||1||
||||+-------+||||+-----+||+---+| ||
|||+---------+||+-------+|     | ||
||+-----------+|         |     | ||
|+-------------+---------+-----+-+|
+---------------------------------+

You can use this code for testing:
f=->s{r=s=s.gsub'}{',?|
r=[s,r,s]*$/while s=s.tr('!-9',' ').gsub!(/{[ |]*}/){$&.tr' -}','-+'}
r.tr'{}',?|}

a=[]

a<<'[1, 2, 3]'
a<<'[[1, 2, 3], [4, 5], [6, 7, 8]]'
a<<'[[[1, 2, 3], [4, 5]], [6, 7, 8]]'
a<<'[]'
a<<'[[], []]'
a<<'[[], [1], [], [2], [], [3], []]'
a<<'[[[[[0]]]]]'
a<<'[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]'

a.map{|s|s.gsub! '], [','}{'
s.tr! '[]','{}'
s.gsub! ',',''
puts s
puts f[s],''}

This starts from the middle row and works outwards. First, instances of }{ are replaced with |. Then, while there are still braces, all innermost {...} strings are transformed into the appropriate +- sequences while characters other than |{} are turned into spaces. At the end, the intermediate braces are turned into pipes.

I took some liberties with the apparently lenient input formatting requirements. The code can be easily modified to handle a different input format, if required.

Receiving poorly thought out comments is one of the great joys of participating on this site.

Ruby, 245 241 bytes
The overhead needed to wrap everything in boxes as well as align everything is pretty heavy...
Outputs arrays of strings, with one string per line, as per the spec. Bottom-aligned instead of the top-aligned sample test cases because it saves 1 byte.
Try it online!
V=->a{a==[*a]?(k=a.map(&V);k[0]==[*k[0]]?[h=?++?-*((k.map!{|z|z[1,0]=[' '*~-z[0].size+?|]*(k.map(&:size).max-z.size);z};f=k.shift.zip(*k).map{|b|?|+b.reduce{|r,e|r+e[1..-1]}+?|})[0].size-2)+?+,*f,h]:[h="+#{?-*(f=k*' ').size}+",?|+f+?|,h]):a}

@Adám it's fixed now. Will try my best to optimize further later...

Nice.First answer with bottom alignment. :-)

PHP+HTML, not competing (170 141 135 130 bytes)
saved 29 bytes inspired by SteeveDroz
<?function p($a){foreach($a as$e)$r.=(is_array($e)?p($e):" $e");return"<b style='border:1px solid;float:left;margin:1px'>$r</b>";}

not competing because it´s no ascii output and because I let the browser do all the interesting work

You can make <b> tags instead of <div> and you don't need to specify the color of the border. (Saving 9 bytes)

You don't need to put a  at all, just display the output as plain text, that will save a lot of bytes (80 bytes for the whole code after HTML removing)

@SteeveDroz With <b>, I can also remove the white-space attribute, saving another 19 bytes. great! And I can replace padding with margin

JavaScript (ES6), 221
A non recursive function returning an array of strings (still using a recursive subfunction inside)
a=>[...(R=(a,l)=>a[r[l]='',0]&&a[0].map?'O'+a.map(v=>R(v,l+1))+'C':a.join` `)([a],l=-1,r=[],m='')].map(c=>r=r.map(x=>x+v[(k<0)*2+!k--],k=l,1/c?v='-- ':(v='-+|',c>'C'?k=++l:c>','&&--l,c='|'),m+=c))&&[...r,m,...r.reverse()]

This works in 2 steps.
Step 1: recursively build a string representation of the nested input array. Example:
[[[1, 2, 3], [],[4, 5]], [6, 7, 8]] -> "OOO1 2 3,,4 5C,6 7 8CC"
O and C mark open and close subarray. Simple numeric subarrays are rendered with the elements separated by space, while if array members are subarrays they are separated by commas. This string keeps track of the multilevel structure of the input array, while I can get the middle row of the output just replacing OC, with |. While recursively building this temp string, I also find the max depth level and initialize an array of empty strings that will contain the half top part of the output.
Note: the outer box is tricky, I nest the input inside another outer array, then I have drop the first row of output that is not needed
Step 2: scan the temp string and build the output
Now I have an array of empty strings, one for each level. I scan the temp string, keeping track of the current level, that increases for each O and decreases for each C. I visualize this like that:
[[[1, 2, 3], [],[4, 5]], [6, 7, 8]]

OOO1 2 3,,4 5C,6 7 8CC
+                    +
 +            +     +
  +     ++   +
|||1 2 3||4 5||6 7 8||

The plus the goes up and down follow the current level
For each char, I add a character to every row of output,  following the rules:
- if digit or space, put a '-' at the current level and below, put a space above
- else, put a '+' at the current level, put a '-' if below and put a '|' if above
OOO1 2 3,,4 5C,6 7 8CC
+--------------------+
|+------------+-----+|
||+-----++---+|     ||
|||1 2 3||4 5||6 7 8||

During the temp scan, I also build the middle row replacing OC, with |
At the end of this step, I have the top half and the middle row, I only have to mirror the top to get the bottom half and I'm done
Less golfed, commented code
a=>{
   r = []; // output array
   R = ( // recursive scan function
     a, // current subarray
     l  // current level
   ) => (
     r[l] = '', // element of r at level r, init to ""
     a[0] && a[0].map // check if it is a flat (maybe empty) array or an array of arrays
     ? 'O'+a.map(v=>R(v,l+1))+'C' // mark Open and Close, recurse
     : a.join` ` // just put the elements space separated
   );
   T = R([a],-1)]; // build temp string
   // pass the input nested in another array
   // and start with level -1 , so that the first row of r will not be visible to .map

   // prepare the final output
   m = '' // middle row, built upon the chars in T
   l = -1 // starting level
   [...T].map(c => // scan the temp string
         {
            k = l; // current level
            1/c // check if numeric or space
             ? v = '-- ' // use '-','-',' '
             : (
                 v = '-+|', // use '-','+','|'
                 c > 'C'
                   ? k=++l // if c=='O', increment level and assign to k
                   : c>'A'&&--l, // if c=='C', decrement level (but k is not changed)
                 c='|' // any of O,C,comma must be mapped to '|'
               );
            m += c; // add to middle row
            r = r.map( (x,i) => // update each output row
                       // based on comparation between row index and level
                       // but in golfed code I don't use the i index
                       // and decrement l at each step
                       x + v[(k<i)*2+!(k-i)]
                     )
         })
   // almost done!
   return [...r,m,...r.reverse()]

)
Test

F=
a=>[...(R=(a,l)=>a[r[l]='',0]&&a[0].map?'O'+a.map(v=>R(v,l+1))+'C':a.join` `)([a],l=-1,r=[],m='')].map(c=>r=r.map(x=>x+v[(k<0)*2+!k--],k=l,1/c?v='-- ':(v='-+|',c>'C'?k=++l:c>','&&--l,c='|'),m+=c))&&[...r,m,...r.reverse()]

out=x=>O.textContent = x+'\n'+O.textContent

;[[1,2,3]
,[[[1, 2, 3], [4, 5]], [6, 7, 8]]
,[]
,[[], []]
,[[], [1], [], [2], [], [3], []]
,[[[[[0]]]]]
,[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]
].forEach(t=>
  out(JSON.stringify(t)+'\n'+F(t).join`\n`+'\n')
)

function update()
{
  var i=eval(I.value)
  out(JSON.stringify(i)+'\n'+F(i).join`\n`+'\n')
}

update()
#I { width:90%}
<input id=I value='[[[1, 2, 3], [],[4, 5]], [6, 7, 8]]' oninput='update()'>
<pre id=O></pre>

PHP, 404 Bytes
All solutions works with maximum depth of the array lesser then 10.
for greater values the depth must store in an array and not in a string.
<?foreach(str_split(json_encode($_GET[a]))as$j){$j!="]"?:$c--;$r=($j==",")?($l=="]"?"":" "):$j;$r=$r=="]"?"|":$r;$r=$r=="["?($v=="]"?"":"|"):$r;if($r!=""){$n.=$r;$d.=+$c;}$v=$l;$l=$j;$j!="["?:$c++;$m>=$c?:$m=$c;}for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

Expanded
foreach(str_split(json_encode($_GET[a]))as$j){ # split JSON representation of the array
    $j!="]"?:$c--;
    $r=($j==",")?($l=="]"?"":" "):$j;
    $r=$r=="]"?"|":$r;
    $r=$r=="["?($v=="]"?"":"|"):$r;
    if($r!=""){
      $n.=$r;  # concanate middle string
      $d.=+$c; # concanate depth position
    }
    $v=$l;
    $l=$j;
    $j!="["?:$c++;
    $m>=$c?:$m=$c; # maximum depth of the array
}
for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
# Build the strings before the middle string dependent of value middle string and depth
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z))); #Output

for 425 Bytes we can make this with REGEX
<?$n=($p=preg_filter)("#\]|\[#","|",$r=$p("#\],\[#","|",$p("#,(\d)#"," $1",json_encode($_GET[a]))));preg_match_all("#.#",$r,$e,256);foreach($e[0] as$f){$f[0]!="]"&&$f[0]!="|"?:$c--;$d.=+$c;$f[0]!="|"&&$f[0]!="["?:$c++;$m>=$c?:$m=$c;}for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

Expanded
$r=preg_filter("#\],\[#","|",preg_filter("#,(\d)#"," $1",json_encode($_GET[a])));
preg_match_all("#.#",$r,$e,256);
$n=preg_filter("#\]|\[#","|",$r); # concanate middle string
foreach($e[0] as$f){
    $f[0]!="]"&&$f[0]!="|"?:$c--;
    $d.=+$c; concanate depth position
    $f[0]!="|"&&$f[0]!="["?:$c++;
    $m>=$c?:$m=$c; # maximum depth of the array
}
# similar to the other ways
for($x=0;$x<strlen($n);$x++)
for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

455 Bytes for a recursive solution
<?function v($x,$t=0,$l=1){global$d;$d.=$t;$s="|";$c=count($x);foreach($x as$k=>$v){if(is_array($v))$e=v($v,$t+1,$k+1==$c);else{$e=$v." "[$k+1==$c];$d.=str_pad("",strlen($e),$t+1);}$s.=$e;}$d.=$l?$t:"";$s.=$l?"|":"";return$s;}$n=v($_GET[a]);$m=max(str_split($d));for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

Expanded
function v($x,$t=0,$l=1){
    global$d; # concanate depth position
    $d.=$t;
    $s="|";
    $c=count($x);
    foreach($x as$k=>$v){
        if(is_array($v)){$e=v($v,$t+1,$k+1==$c);}
        else{$e=$v." "[$k+1==$c];$d.=str_pad("",strlen($e),$t+1);}
        $s.=$e;
    }
    $d.=$l?$t:"";
    $s.=$l?"|":"";
    return$s;
}
$n=v($_GET[a]); # concanate middle string
$m=max(str_split($d)); # maximum depth of the array
# similar to the other ways
for($x=0;$x<strlen($n);$x++)
for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

$j!="]"?:$c--; -> $c-=$j=="]"; (-2). 2) ($l=="]"?"":" ") -> " "[$l==$j] (-5). Most probably similar substitutions in the second loop. 3) if($r!=""){$n.=$r;$d.=+$c;} -> $n.=$r;if($r>"")$d.=+$c; (-3). 4) $l=$j;$j!="["?:$c++; -> $c+="["==$l=$j; (-5). 5) $x=0 is not needed (-4). 6) for($y=0;$y<$m;$y++) -> for($y=$m;$y--;) (-4). 7) join("\n",$z),"\n$n\n".(join("\n",array_reverse($z))); -> join("\n",array_merge($z,[$n],array_reverse($z))); (-4) 8) unnecessary whitespace: foreach($e[0]as$f) (-1)

unecessary parentheses at ($j==",") (-2). 10) if($r>"")$d.=+$c; -> $d.=$r>""?+$c:""; (-0)

recursive version:

$d.=$l?$t; is obsolete (-10)
$s.=$l?"|":"";return$s; -> return$s."|"[$l]; (-6).
obsolete braces {$e=v($v,$t+1,$k+1==$c);} (-2).
{$e=$v." "[$k+1==$c];$d.=str_pad("",strlen($e),$t+1);} -> $d.=str_pad("",strlen($e=$v." "[$k+1==$c]),$t+1); (-5).


text:
Let's get ready for Halloween
I don't know about you all but I'm not preparing for Halloween––never did never will––but, my neighbor is, so we'll help her out.
She needs help figuring out which brand of candy she has, but she has so much candy she would not be able to finish before Halloween.
She has:

Snickers
KitKat
Starburst
GummyBears
Twix

Input
A multiline string (or any other reasonable form) containing only letters and spaces.
Output
A falsy value if it is not a valid candy, or which candy it is if it is a candy.
How to decide which candy it is
A candy is valid if it says one of the above brands on it. However, it's not that simple, because this is a valid candy:
K i t
       K a
           t

A valid candy is one where:

the letters are in order from left to right
the letters are capitalized correctly
the letters, going from left to right, do not both ascend and descend
the letters with whitespace removed form one of the above brands

This is code-golf, so shortest code in byte wins!
Examples
Truthys:
1.
              kers
           c
        i
       n
    S

2.
  Kit K a t

3.
St a
    r b u
         r st

4.
         Bear s
G ummy

5.
T w i
                          x

Falsys:
1.
SNICKERS

2.
 C   n

   a   d y

3.
xiwT

4.
S C I
       ss o
              r       s

5.
Kit
Kat

Can the input be padded with spaces?

Also, does throwing an error count as returning a falsely value?

@Loovjo, yes and yes

Can we assume no blank lines?

@anonymous2, the input will not be empty

Your neighbour should have had lollipop, marshmallow and nougat along with KitKat...

I think @anonymous2 meant with no blank lines something like this: Twi\n\n\n    x (  = space, comments aren't showing property regarding spaces).

With the rule "the letters, going from left to right, do not both ascend o̶r̶  and? descend", do you mean a test case like T i\n w x is a false test-case, since it's starting at line 1, goes to line 2, back to line 1, back to line 2?

@KevinCruijssen, oh well there could be an empty line in the input (only whitespace). Also, yes. The second falsy test case addresses that rule. I'll fix my wording.

@Dopapp Ah, regarding the second falsey test case, I thought it was false because it was "Candy", which isn't in the list of candies she has (Snickers; KitKat; Starburst; GummyBears; Twix)

@KevinCruijssen, well that too

Pyth - 72 bytes
I hope I caught all the edge cases. Will base compress candy list.
&sSIM_Bmxdh-d;fnd{TK.tQd}-sKdc"Snickers KitKat Starburst GummyBears Twix

Test Suite.

JavaScript (ES6), 221 218 216 212 208 205 201 bytes
f=a=>(c=d=L=0,e=1,s=[],[...a].map(a=>a=='\n'?c=L=0:c++-(a!=' '&&(s[c]?e=0:(!L&&(d?d-1?e&=c>Q>d-3:d=c>Q>2:d=1),L=s[Q=c]=a)))),e&&'Snickers0KitKat0Starburst0GummyBears0Twix'.split(0).indexOf(s.join``)+1)

Try it here.

Welcome to PPCG, and great first answer! Unfortunately, I don't believe this is valid; it returns a truthy value for Snick, ears|T, etc. I think you can fix this by adding .split('|') before .indexOf.

This is valid now.

@ETHproductions. The ears|T is not the problem because only letters are allowed in test cases. However, you are right, for Snick.

Use this for -2

You can also use this trick to save several bytes.

@ETHproductions. Correct. It actually saves 4 bytes.

You can also remove the parentheses around (e&=d-2-(c<Q)) and (d=2+(c>Q)), and replace a.split``.map with [...a].map.

Racket 446 bytes
(let((lr list-ref)(ls list-set)(sl string-length)(ss substring)(l(string-split s "\n")))(let loop((changed #f))(for((i(sub1(length l))))
(let*((s(lr l i))(r(lr l(add1 i)))(n(sl s))(m(sl r)))(when(> n m)(set! l(ls l i(ss s 0 m)))(set! l(ls l(add1 i)
(string-append r(ss s m n))))(set! changed #t))))(if changed(loop #f)(begin(let*((l(for/list((i l))(string-trim i)))(l(string-join l))
(l(string-replace l " " "")))(ormap(λ(x)(equal? x l))cl))))))

Ungolfed:
(define (f s cl)
  (let ((lr list-ref)
        (ls list-set)
        (sl string-length)
        (ss substring)
        (l (string-split s "\n")))
    (let loop ((changed #f))
      (for ((i (sub1 (length l))))
        (let* ((s (lr l i))
               (r (lr l (add1 i)))
               (n (sl s))
               (m (sl r)))
               (when (> n m)
                 (set! l (ls l i (ss s 0 m)))
                 (set! l (ls l (add1 i)(string-append r (ss s m n))))
                 (set! changed #t))))
        (if changed (loop #f)
            (begin
              (let* ((l (for/list ((i l))
                          (string-trim i)))
                     (l (string-join l))
                     (l (string-replace l " " "")))
                (ormap (λ(x) (equal? x l)) cl)))
            ))))

Testing:
(f "
              kers
           c
        i
       n
    S"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "  Kit K a t"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "St a
    r b u
         r st "
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "         Bear s
G ummy"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "T w i
                          x"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "SNICKERS"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))
(f " C   n
          y
   a   d"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "xiwT"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "S C I
       ss o
              r       s"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "Kit
Kat"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

Output:
#t
#t
#t
#t
#t
#f
#f
#f
#f
#t

I think you named your output "Ungolfed"

Yes. I have corrected the mistake. Thanks.

JavaScript (ES6), 139 bytes
a=>/^(Snickers|KitKat|Starburst|GummyBears|Twix)$/.test(a.reduce((s,t)=>s.replace(/./g,(c,i)=>c<'!'?t[i]:t[i]<'!'?c:'!')).replace(/ /g,''))

Accepts input as an array of space-padded strings.

Python 2.7, 254 bytes
I'm sure this can be golfed more. Input is an array of lines s.
x=len
p=lambda a:x(a)-x(a.lstrip())
g=sorted
a=map(p,l)
j=''.join
z=[i.replace(' ','')for i in l]
if g(a)==a:q=j(z)
elif g(a)==a[::-1]:q=j(z[::-1])
else:q=''
if x(set(a))<x(a):q=''
print 1if q in('Snickers','KitKat','Starburst','GummyBears','Twix')else 0

Try it here!

You can take the input as a string array/list, so there is no need to split it in the first line of your code.

R, 199 chars
function(M){if(any(outer(z<-diff(apply(M,1,function(r)which.min(r==" ")))),z<0))return(F);C=c("Twix","KitKat","Starburst","Snickers","GummyBears");C[match(paste0(gsub(" ","",c(t(M))),collapse=""),C)}

Input is in the form of a character matrix.
match takes care of which candy it is (it checks capitalisation too).
To check that the letters are an "ascending" or "descending" sequence, we just need to check that the locations of the first non-space character (if there) in each row is increasing or decreasing. To do, this we

take the first location of a nonspace character in each row, using apply
take the diff. This might have some zero in it, otherwise should either be all positive or all negative
name the diff z, and take the outer product with itself. If the diff had mixed positive and negative entries, there will be a negative entry somewhere in its outer product. If so, return FALSE.

Note that cases like
"    i "
"   w x"
"  T   "

will return an empty character vector (in particular not "Twix"), since match will be trying to match "Twxi".

source: Stack Exchange

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

sort: votes


text:
Print the Greek alphabet in words
This is different from Print the Greek alphabet! because it is in words.
This is different from "Hello, World!" because the output is different and much longer, leading to different techniques.
This is different from We're no strangers to code golf, you know the rules, and so do I because the output is different and much shorter, leading to different techniques.
Your task is to print this exact text: (the Greek alphabet in words)
alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu xi omicron pi rho sigma tau upsilon phi chi psi omega

Capitalization does not matter.
Remember, this is code-golf, so the code with the smallest number of bytes wins.

@EasterlyIrk How is this a duplicate of that? It's completely different.

How? It's just printing a static string.

Related.

You know, had you posted this in the Sandbox, you could've avoid the downvotes by getting told it's a dupe of HW before posting it on main...

Specifically, it could be considered either a dupe of HW or a dupe of http://codegolf.stackexchange.com/q/6043/45941

@mego I don't think it's a great challenge, but I don't think either of those are great dupe targets. Mostly because of length. HW is really short and strangers to code-golf is really long (and fairly compressible)

I agree that this should have been vetted in the Sandbox, I also agree that this ISN'T a dupe. The length of the required output plays a definite role here.

Python 2, 99 81 bytes
from unicodedata import*
i=913
exec"print name(unichr(i+(i>929)))[21:],;i+=1;"*24

Thanks to @xnor for saving 15 bytes!
This uses the unicodedata.name() method
 to get the name of every character. Unfortunately, the code point 930 gives an error for some reason, so that cost a few extra bytes.
This also prints the output in uppercase, which is allowed.

Nice find with the unicode data. I golfed it to 81: from unicodedata import*;i=913;exec"print name(unichr(i+(i>929)))[21:],;i+=1;"*24.

Scala, 76 bytes
print((913 to 937)filter(930!=)map(Character getName _ drop 21)mkString " ")

Explanation:
print(                  //print...
  (913 to 937)            //build a range of the codepoints for aplha to omega
  filter(930!=)           //filter out that sigma in the middle
  map(                    //map each char...
    Character getName _     //to its full unicode name, e.g. "GREEK CAPITAL LETTER ALPHA"
    drop 21                 //and drop the first 21 chars, aka "GREEK CAPITAL LETTER "
  )
  mkString " "            //join them with a space
)

Jolf, 7 bytes
RΜpΧ΅z♣

Replace ♣ with 0x05, or try it here! Or, use this link to generate the code. (Just click run, the code will be written into the code box.)
Explanation
RΜpΧ΅z♣
 ΜpΧ     map Greek character alphabet
    ΅z    with the toGreek function (converts greek characters to names)
R     ♣  and join that with spaces.

+1 for the toGreeek function

///, 119 117 bytes
/1/eta //2/psilon //3/a /alph3b1gamm3delt3e2z11th1iot3kapp3lambd3mu nu xi omicron pi rho sigm3tau u2phi chi psi omega

-2 bytes thanks to steenbergh
Try it online!

You can save 2 bytes by doing this /2/psilon /

PHP, 68 characters, 92 bytes
<?=strtr(htmlentities(αβγδεζηθικλμνξοπρστυφχψω),["&"=>"",";"=>" "]);

uses UTF-8; prints a trailing space. Run with -nr.

turn the lowercase greek alphabet into html entities
remove ampersands and replace semicolons with spaces
print

Try it online

BF, 1265 bytes
++++++++++.--[--->++++<]>+.+++++++++++.++++.--------.-------.-[->+++<]>.[->+++<]>++.+++.[--->+<]>---.+[->+++<]>++.-[->+++<]>.++[->+++<]>+.------.++++++++++++..------------.-[->+++<]>.+[->+++<]>+.+.+++++++.++++++++.+[->+++<]>++.-[->+++<]>.+[->+++<]>++.+++++++++++.+++.----------.+++.+++.-.-[->+++++<]>-.-[->++++<]>--.---[->+++<]>.[--->+<]>---.+[->+++<]>++.-[->+++<]>.+[->+++<]>++.[--->+<]>---.+[->+++<]>++.-[->+++<]>.---[->++++<]>.------------.---.[--->+<]>---.+[->+++<]>++.-[->+++<]>.-[--->++<]>-.++++++.+++++.+[->+++<]>++.-[->+++<]>.-[--->++<]>+.----------.-[++>-----<]>..[----->++<]>+.-[->+++<]>.++[--->++<]>.-----------.++++++++++++.-----------.++.---.-[->+++<]>.+[----->+<]>.++++++++.-[---->+<]>+++.+[----->+<]>+.+++++++.-[---->+<]>+++.--[->++++<]>.[->+++<]>+.[--->+<]>---.+++++[->+++<]>.--.----.------.-[--->+<]>----.---.-.-[->+++++<]>-.[-->+++++++<]>.-------.[--->+<]>---.---[----->++<]>.----------.+++++++.[--->+<]>-----.---[->++++<]>-.----------.--.++++++.------------.-[->+++<]>.---[->++++<]>.+[->+++<]>++.--[--->+<]>.-[---->+<]>+++.---[->++++<]>+.-----.+++.----------.+++.+++.-.-[->+++++<]>-.[-->+++++++<]>.--------.+.[--->+<]>---.+[->+++<]>.+++++.+.[--->+<]>---.[-->+++++++<]>.+++.----------.[--->+<]>---.+++++[->+++<]>.--.--------.++.------.>++++++++++.

How and WHY...?

Why not? Sometimes longer can be better :) @carusocomputing

Mathematica, 85 66 bytes
Thanks to ngenisis for pointing the way to a 19-byte savings!
CharacterName@Alphabet@"Greek"~Riffle~" "~StringDelete~"Curly"<>""

Returns the string with every Greek letter capitalized. Just thought it would be fun to coerce Mathematica into doing all the work!
Alphabet@"Greek" returns a nicely formatted list of the Greek alphabet characters; CharacterName@ converts each of those characters into a string naming that character, and ~Riffle~" " inserts a space between each such string. Unfortunately, two of the letters are called "CurlyEpsilon" and "CurlyPhi", and so we need ~StringDelete~"Curly" to fix that. Finally, <>"" concatenates all these strings together.
Previous submission:
StringDelete[ToString@FullForm@Alphabet@"Greek","List"|"Curly"|"["|"]"|"\""|"\\"|","]

Alphabet@"Greek" returns a nicely formatted list of the Greek alphabet characters as before, but FullForm forces it to show the internal structure rather than the nice formatting; ToString converts that internal structure into a string that can be manipulated:
"List[\"\\[Alpha]\", \"\\[Beta]\", \"\\[Gamma]\", \"\\[Delta]\", \"\\[CurlyEpsilon]\", \"\\[Zeta]\", \"\\[Eta]\", \"\\[Theta]\", \"\\[Iota]\", \"\\[Kappa]\", \"\\[Lambda]\", \"\\[Mu]\", \"\\[Nu]\", \"\\[Xi]\", \"\\[Omicron]\", \"\\[Pi]\", \"\\[Rho]\", \"\\[Sigma]\", \"\\[Tau]\", \"\\[Upsilon]\", \"\\[CurlyPhi]\", \"\\[Chi]\", \"\\[Psi]\", \"\\[Omega]\"]"

From here, StringDelete[..."List"|"Curly"|"["|"]"|"\""|"\\"|","] gets rid of all the stuff we don't want.

StringDelete[Riffle[CharacterName@Alphabet@"Greek"," "]<>"","Curly"]

oooo, CharacterName!

Pyth - 104 83 bytes
Base conversion with separator f. Unfortunately, it starts with smallest code point a.
tX."azT¢ç§ªVôòé!þm<EÞ6ä¿û2_w}MªÍ]·¥ünBPæúòRÜÔYcWed¼(É?«/~{"\fd

Try it online here.

Python 2 is beating you. :D

@mbomb007 :/ that doesn't count...

Pyth is just short Python, right?

Jelly, 58 bytes
“ßẓ⁸!ȧøḌçỊ¤¢Q=4QẠė⁷¤yż>S⁺ẓṬḄṂċK~⁼Ṛ7&⁼s<ụɦ³ḳMŻyVẉƑƭ6Ẋ⁵ỌQ⁸ẹ»

Try it online!

Perl 6, 47 bytes (44 characters)
put squish ~«map {.uniname~~/\w+$/},"α".."ω"

Prints LAMDA instead of LAMBDA, bus so do the other Unicode database based solutions.
Try it online!

A 70-byte solution that prints the exact output: put (lc squish ~«map {.uniname~~/\w+$/},"α".."ω").subst("md","mbd")

05AB1E, 86 bytes
“¤±¢ªœÏ¤œ epsilon zeta etaìÛ iota kappaÊ¯ mu nu xi omicron¾î rho¿Ã tau upsilonÐ¢Â¶á‚Åµ

Try it online!

Perl6 (71)
(913..937).grep(*!= 930)>>.chr>>.uniname>>.substr(21).join(" ").lc.say

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


text:
Fill in the Minesweeper clues
Minesweeper is a popular puzzle game where you must discover which tiles are "mines" without clicking on those tiles. Each tile is either a mine (represented by *) or a clue, i.e. a number from 0 to 8 representing how many of the 8 neighboring tiles are mines. Your task today is to take a board containing the mines and fill in all of the clues. For example, look at the following 5x4 board, with 5 mines:
 *
*  *
  *
    *

After filling in the clues, the board will look like this:
2*211
*33*1
12*32
0112*

Details
You must write either a full-program or a function that takes in a grid of characters containing only spaces and asterisks and outputs another grid where each space is replaced with the number of adjacent mines (asterisks). Any of these are acceptable formats for your grids:

A string with newlines in it
A 2D list of characters/single character strings
A list of strings

You can assume the grid will be at least 1x1, although it is possible for it to be all mines or all spaces.
The input grid will always be padded with the appropriate number of spaces. As usual, this is code-golf, so standard loopholes apply and the shortest answer in bytes wins!
Sample IO
So that you can see the whitespace, I will show all sample IO with brackets around it.
Input:
[    * ]
[*     ]
[      ]
[      ]
[  **  ]
[ *  * ]

Output:
[1101*1]
[*10111]
[110000]
[012210]
[12**21]
[1*33*1]

Input:
[****]
[****]

Output:
[****]
[****]

Input:
[   ]
[   ]
[   ]
[   ]

Output:
[000]
[000]
[000]
[000]

Input:
[*   ]
[**  ]
[    ]
[   *]

Ouput:
[*310]
[**10]
[2221]
[001*]

Input:
[**    ]
[*    *]
[  *   ]
[      ]
[*     ]
[****  ]

Output:
[**1011]
[*4211*]
[12*111]
[121100]
[*43210]
[****10]

Input:
[     *    ]
[        * ]
[     *    ]
[**   ***  ]
[      *** ]
[          ]
[       ** ]
[  * *     ]
[*      ** ]
[       ** ]

Output:
[00001*1111]
[00002221*1]
[22102*4321]
[**102***31]
[221013***1]
[0000013542]
[0112111**1]
[12*2*12442]
[*212112**2]
[1100002**2]

FYI, I made all of the sample IO by hand, so it's possible there are some minor errors in there. Let me know if something looks off and I'll try to fix it ASAP.

Related.

Can the grid be non-square ?

Can the mines represented by another character?

@ChristianIrwan No, the mines will always be an asterisk.

Can my output contain leading blank lines?

Can we take I/O with brackets around it?

@Lynn I guess that's fine.

@DestructibleWatermelon Re brackets around input: I don't see why that would make any difference, but I guess I don't have any problem with it.

Your first example says "look at the following 5x5 board", but in both the asterisk display and the numbers below it have 5 columns and 4 rows.

MATL, 18 17 bytes
Thanks to @mbomb007 for a correction in the input of test case 6
32>t3Y6Z+-6b(48+c

Input is a 2D char array, in the format
[' *   '; '*  * '; '  *  '; '    *']

Try it online!
Test cases: 1,
 2, 3, 4, 5, 6.
Explanation
32>      % Input 2D char array implicitly. Transform it into a 2D logical
         % array with asterisk replaced by true and space by false
t        % Duplicate
3Y6      % Push [1 1 1; 1 0 1; 1 1 1]. This defines the neighbourhood
Z+       % 2D convolution, keeping size. Gives the number of neighbouring
         % mines for each position
-6       % Push -6
b        % Bubble up in stack
(        % Assign -6 to the entries indicated by the logical array, i.e.
         % to the positions that originally contained asterisks
48+      % Add 48. This transforms each number of neighbouring mines
         % into its ASCII code, and -6 into 42 (ASCII code of asterisk)
c        % Convert to char. Display implicitly

Wow. That is impressive.

Getting test case 6 would piss me off playing the actual game.

Why?  Test case 6 seems the most realistic.

@carusocomputing Getting test case 2 would piss me off a lot more. :P

JavaScript (ES6), 114 96 bytes
a=>a.map((s,i)=>s.replace(/ /g,(_,j)=>g(k=>(s=a[i+k])?g(k=>s[j+k]>' '):0)),g=f=>f(-1)+f(0)+f(1))

Edit: Saved 18 bytes thanks to an idea by @ETHproductions.

I think you can save a bunch by defining a function to check if an index is non-space: a=>a.map((s,i)=>s.replace(/ /g,(_,j)=>a.slice(i-!!i,i+2).reduce((t,s)=>t+(q=i=>s[i+j]>' ')(-1)+q(0)+q(1),0)))

@ETHproductions I took your idea to the extreme... I don't usually get to write function parameters!

R, 127 112 bytes
function(M){a=nrow(M);for(i in seq(M))if(M[i]!="*")M[i]=sum(M[pmax(i+c(-1,1,-a+-1:1,a+-1:1),0)]=="*",na.rm=T);M}

thanks to @gtwebb and @sebastian-c for improvements.
Notable points:
Matrices are vectors in R. You don't need 2-D indexing to get elements out.
seq(M) will return a sequence of the same "length" (rows x columns) as M.
You can't mix positive and negative extraction indices in R. M[-3] is legitimate R code, but not what is desired.
Input is in the form of an R matrix. Some examples:
> M <- matrix("",5,5)
> M[3,3] <- "*"
> f(M)
     [,1] [,2] [,3] [,4] [,5]
[1,] "0"  "0"  "0"  "0"  "0"
[2,] "0"  "1"  "1"  "1"  "0"
[3,] "0"  "1"  "*"  "1"  "0"
[4,] "0"  "1"  "1"  "1"  "0"
[5,] "0"  "0"  "0"  "0"  "0"
> M[2,2] <- "*"
> f(M)
     [,1] [,2] [,3] [,4] [,5]
[1,] "1"  "1"  "1"  "0"  "0"
[2,] "1"  "*"  "2"  "1"  "0"
[3,] "1"  "2"  "*"  "1"  "0"
[4,] "0"  "1"  "1"  "1"  "0"
[5,] "0"  "0"  "0"  "0"  "0"
> M[3,2] <- "*"
> f(M)
     [,1] [,2] [,3] [,4] [,5]
[1,] "1"  "1"  "1"  "0"  "0"
[2,] "2"  "*"  "3"  "1"  "0"
[3,] "2"  "*"  "*"  "1"  "0"
[4,] "1"  "2"  "2"  "1"  "0"
[5,] "0"  "0"  "0"  "0"  "0"
>

You can cut a few characters off by using T instead of TRUE. I managed to slide some braces off one of the if functions too:
f=function(M){a=nrow(M);b=ncol(M);for(i in seq(M))if(M[i]!="*")M[i]=sum(M[pmax(i+c(-1,1,-a+-1:1,a+-1:1),0)]=="*",na.rm=T);M}

You define b=ncol(M) and then don't use it so you could get rid of that.

I can shave off four characters (and vectorise): M->{a=nrow(M);p=M=='*';M[]=ifelse(p,'*',sapply(seq(M),i->sum(p[pmax(i+c(-1,1,-a+-1:1,a+-1:1),0)],na.rm=T)))} — however, this cheats slightly because it requires a redefined <- lambda, see klmr/functional/lambda

@Konrad interesting idea, but I'll keep it to base R thanks!

Java, 190 bytes
Edit:

-6 bytes off. Thanks to @Frozn
-1 byte off. Thanks to myself :)
-1 byte off. Also spotted some mistakes. Thanks to @Kevin Cruijssen

Snipet
c->{for(int x,y,j,i=-1;++i<c.length;)for(j=-1;++j<c[0].length;){if(c[i][j]<33){c[i][j]=48;for(x=i-2;++x<i+2;)for(y=j-2;++y<j+2;)try{if(c[x][y]==43)c[i][j]++;}catch(Exception e){}}}return c;}

Ungolfed:
public class Main{
  public static char[][] minesweeper(char[][] woclues){
    for(int i = 0; i < woclues.length ; i++){
      for(int j = 0; j < woclues[0].length ; j++){
        if( woclues[i][j] == ' '){
          woclues[i][j] = '0';
          for(int x = i - 1; x < i + 2 ; x++){
            for(int y = j - 1; y < j + 2 ; y++){
              try{
                if(woclues[x][y] == '*'){
                  woclues[i][j]++;
                }
              }catch( ArrayIndexOutOfBoundsException e){}
            }
          }
        }
      }
    }
    return woclues;
  }
  public static void main(String[]args){
    char[][] in = new char[args.length][args[0].length()];
    for(int i = 0; i < args.length;i++){
      in[i]=args[i].toCharArray();
    }
    for(char[] c:minesweeper(in)){
      System.out.println(new String(c));
    }
  }
}

Ideone it.

You can compare the char values against the ASCII values which should be shorter in most cases. You can also combine the declarations of x,y,i,j

I already did c[i][j]==32 and so on and just changed them in the Ungolfed part

And I'm shorter than Phyton. At least!

Are you sure your ungolfed code is correct? For the first test case it outputs: 0000*1\n*10011\n110000\n000000\n00**10\n0*22*1. Could you perhaps add an ideone.com test link? EDIT: Also, unless I'm doing something wrong myself, your golfed code output: ssss0s\n0sssss\nssssss\nssssss\nss00ss\ns0ss0s for the first test case (it has replaced all * with zeros..) :S

Edited. I'll add a test link as soon as my pior internet allows that to me.

@RomanGräf Your ungolfed code works now, your golfed code not yet. If I'm not mistaken the >33 should be <33 instead. Also, you have a closing parenthesis too many right after the catch(Exception e){}) <- this last one should be removed. +1 though, after these two changes everything seems to work great.

You could remove the whole return keyword and use a function with a void return type. You only have to say that your output is expressed in the original array. Nowhere is it written that the output must be the return value. Also, braces after the 2nd for and before the first if aren't necessary.

I don't think your second for-loop needs curly braces. Saves 2 bytes

JavaScript (ES6) 186 182 177 161 152 bytes
f=a=>{for(s='',y=a[0].length;y--;)for(s=`
`+s,x=a.length;x--;)(k=>{for(t=0,i=9;i--;)t+=(a[x+i%3-1]||[])[y+i/3-1|0]==k;s=(a[x][y]<k?t:k)+s})`*`;return s}

Update
The above code for " *" returns "2*". This is fixed in the following script.
168 167 bytes
f=a=>{for(s='',y=a[0].length;y--;)for(s=`
`+s,x=a.length;x--;)a[x][y]=='*'?s='*'+s:(k=>{for(t=0,j=3;j--;)for(i=3;i--;)t+=(a[x+i-1]||1)[y+j-1]=='*';s=t+s})`*`;return s}

Try it here.

I think t+=(a[x+i%3-1]||[])[y+i/3-1|0]==k should work in a similar way and save you the try / catch part.

@Arnauld. Actually, reading a property of literal number will not throw an error, so it can be also improved as (a[x+i%3-1]||1)[y+i/3-1|0].

Python 2, 138 bytes
def f(s):w=s.find('\n')+1;print''.join([c,`(s[i-(i>0):i+2]+(w*' '+s)[i-1:i+2]+s[i-1+w:i+2+w]).count('*')`][c==' ']for i,c in enumerate(s))

Defines a function f that accepts an input string like
"  *\n** \n*  \n"

and prints a string to STDOUT:
23*
**2
*31

Make enumerate start from 2 (enumerate(s,2)), and replace all occurrences of i + 2 with i and i - 1 with i - 3. That'll shave off a couple of bytes.

JavaScript (ES6), 107
Input/output as an array of strings
f=l=>l.map((r,i)=>r.replace(/ /g,(c,j)=>(s=r=>(c+r).substr(j,3).split`*`.length,s(l[i-1])+s(l[i+1])+s(r)-3)))

note when the function s is called with an element of the list l out of the bounds, the parameter a is undefined and c+a will result in " undefined" thanks to the quirky conversion rules of javascript
More readable
l=>
  l.map(
    (r,i) =>
      r.replace(/ /g, (c,j) =>
        (
          s = a => (c+a).substr(j,3).split`*`.length,
          s(l[i-1])+s(l[i+1])+s(r)-3
        )
      )
  )

Haskell, 115 bytes
z=zip[1..]
x%i=[a|(j,a)<-z x,abs(i-j)<2]
f x=[[head$[c|c>' ']++show(sum[1|'*'<-(%j)=<<x%i])|(j,c)<-z r]|(i,r)<-z x]

Defines a function f on lists of strings

Python 2, 192 bytes
-3 bytes thanks to Copper, -10 bytes if modifying the input grid is allowed, another -11 bytes by getting rid of continue and another -12 bytes for eliminating the counter variable
def f(L):
 n,S,s=len(L[0]),[0,1,2],[' '];P=[s*(n+2)];K=P+[s+x+s for x in L]+P
 for y in range(len(L)):
    for x in range(n):
     if'*'!=L[y][x]:L[y][x]=`sum(K[y+d][x+e]=='*'for d in S for e in S)`

Uses a list of list of characters L and creates a padded version K, so no problem at boundaries. Indentation is

Space
Tab
Tab+Space
Tab+Tab

Usage:
s=""" *
*  *
  *
    *"""
print s
s=[[c for c in x] for x in s.split('\n')]
f(s)
s='\n'.join([ ''.join(x) for x in s])
print s

A few minor golfs: you can put your first three variables assignments on the same line separated with semicolons and lose the indentation. Also, use if'*'==L[y][x]: to save a byte.

If you assign r=range; on the same line as n,S,s, you can save five characters by replacing the calls to range(...) with r(...).

@alexwlchan doing this saves 2*ange so 8 bytes, but i have to add ,r and ,range which is also 8 bytes so nothing earned.

@KarlNapf Gah, you're right -- I'd forgotten about the range.

Ruby, 112
Takes and returns a string. String must be newline separated and newline terminated.
->s{w=1+s=~/\n/
s.size.times{|i|s[i]==' '&&(n=0;9.times{|j|(s+$/*w)[i+j%3-1+j/3*w-w]==?*&&n+=1};s[i])=n.to_s}
s}

in test program
f=->s{
  w=(s=~/\n/)+1                              #Calculate width.
  s.size.times{|i|                           #For each char in s
    s[i]==' '&&(                             #If it is a space
      n=0                                    #set counter n to 0 and visit
      9.times{|j|                            #a 3x3 square of chars.
        (s+$/*w)[i+j%3-1+j/3*w-w]==?*&&n+=1  #If *, increment n.
      }                                      #(Pad s with w newlines to avoid *'s detected by wraparound.)
      s[i]=n.to_s                            #Write n back to s in string format
    )
  }
s}                                           #Return s.

puts f[
" *
*  *
  *
    *
"]

TSQL 292 291 bytes
Golfed:
DECLARE @ varchar(max)=
' *
*  *
  *
    *';
WITH C as(SELECT x+1i,substring(@,x+1,1)v,x/z r,x%z c FROM master..spt_values CROSS APPLY(SELECT number x,charindex(char(10),@)z)z WHERE type='P'and x<len(@))SELECT @=stuff(@,i,1,z)FROM(SELECT i,(SELECT count(*)FROM C WHERE abs(D.c-c)<2and abs(D.r-r)<2and'*'=v)z FROM C D WHERE''=v)h PRINT @

Ungolfed:
DECLARE @ varchar(max)=
' *
*  *
  *
    *';
WITH C as
(
  SELECT x+1i,substring(@,x+1,1)v,x/z r,x%z c
  FROM master..spt_values
  CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
  WHERE type='P'and x<len(@)
)
SELECT @=stuff(@,i,1,z)
FROM
(
  SELECT
    i,
    (
      SELECT count(*)
      FROM C
      WHERE
       abs(D.c-c)<2and abs(D.r-r)<2and'*'=v
    )z
  FROM C D
  WHERE''=v
)h
PRINT @

Fiddle

Does the ; at the front of your code count? It seems that you have counted it.

@EriktheGolfer Yes, where there is script prior to WITH. Compiler will give an error if it is removed. It is possible to test ideas in the fiddle

I mean, should it be in the byte count of the general source? Because it seems like it should be part of the "Initial STDIN" statement instead.

@EriktheGolfer I don't really know, I suppose it can be part of the declaration. Can also exclude  master.. if there is a USE master in the beginning of the script. But it gives an annoying message in the fiddle.

I tried putting the semicolon on the previous line, and it worked. I assume the last line is what counts.

Adjusted the count and code, thanks

Racket 415 bytes
(let*((l(string->list s))(g (λ(r c)(if(or(>= r n)(>= c n)(< r 0)(< c 0))#f(list-ref l(+ c(* n r))))))(ng (λ(r c)(let*((h'(-1 0 1))(k(filter(λ(x)x)
(for*/list((i h)(j h)#:unless(= 0 i j))(g(+ r i)(+ c j))))))(count(λ(x)(equal? x #\*))k))))(k(for*/list((i n)(j n))(ng i j)))
(ol(map(λ(x y)(if(equal? x #\*)"*"(number->string y)))l k)))(for((i(* n n))(j ol))(display j)(when(= 0(modulo(add1 i)n))(displayln ""))))

Ungolfed:
(define (f s n)
  (let* ((l (string->list s))
         (get                            ; fn to get value at a (row, col)
          (lambda(r c)                   ; #f if invalid row or col
            (if (or (>= r n)
                    (>= c n)
                    (< r 0)
                    (< c 0))
                #f (list-ref l (+ c (* n r))))))

         (neighbors                      ; fn to count neighboring "*"
          (lambda(r c)
            (let* ((h '(-1 0 1))
                   (u (filter
                       (lambda(x) x)
                       (for*/list ((i h)(j h)
                                   #:unless (= 0 i j))
                         (get (+ r i) (+ c j))))))
              (count (lambda(x)(equal? x #\*)) u))))

         (k (for*/list ((i n) (j n))    ; for each row,col count neighboring "*"
              (neighbors i j)))
         (ol(map (lambda(x y)           ; get outlist- replace blanks with neighboring star count
                   (if(equal? x #\*)
                      "*"
                      (number->string y)))
                 l k)))

    (for ((i (* n n))(j ol))            ; display outlist
      (display j)
      (when (= 0 (modulo (add1 i) n))
        (displayln "")))))

Testing (lists as a single string with column number specified; will also work with spaces):
(f "----*-*-------------------**---*--*-" 6)

Output:
1101*1
*10111
110000
012210
12**21
1*33*1

PHP, 145 133 132 127 bytes
for($s=$argv[1];$s[$p];print$c)if(" "==$c=$s[$p++])for($y=-2;$y++<1;)for($x=$p-3;$x++<$p;)$c+="!"<$s[$x+$y*strpos($s,"\n")+$y];

takes input as single string, newline separated. Run with -r.
breakdown
for($s=$argv[1];$s[$p]; // loop through all characters (including newlines)
    print$c                     // 3. print result
)
    if(" "==$c=$s[$p++])        // 1. if character is space
        for($y=-2;$y++<1;)      // 2. count surrounding asterisk characters
            for($x=$p-3;$x++<$p;)
                $c+="!"<$s[$x+$y*strpos($s,"\n")+$y];

"!">$n=$s[$p] instead of " "==$n=$s[$p] saves one Byte

@JörgHülsermann That would destroy the linebreaks.

@JörgHülsermann ... but the trick works for the asterisk comparison (in the new version)

Turtlèd, 99 bytes
(whoops I keep forgetting the link :| )
Takes inputs with brackets around each line
Turtlèd cannot take multi-line input, so after the last line, write | to signal end of input
Note the mismatched brackets are because open brackets parse the next char as part of the bracket command
[|!.([[]r+.][[l]d)][ u]d[|[]r( #012345678#l(*+)u(*+)r(*+)r(*+)d(*+)d(*+)l(*+)l(*+)ur.)]' [[l]' d]'

Try it online!
How it works (general description):
Until | is entered, it writes out the input on each line, with brackets to help it recognise the end of each line.
After that has happened, it goes back up to the top of input. It goes through each character in input. If it is a space, it looks around the space, adding one to the counter for each bomb it finds. after each line, it deletes the brackets. When it gets to the last line, with the | in it, it stops, and deletes the |. the grid is implicitly printed.

APL (Dyalog Unicode), 24 bytes
{4⌷x←'*'=,⍵:'*'⋄+/x}⌺3 3

Try it online!
A direct stencil operation.
Input as a character matrix, output as a hybrid matrix.
Testcase converter

Vyxal 3 j, 18 bytes
Þȯᵛᵛ•CZᵗZᵛᵛ₳•c¿•]“

Try it Online!
input is a list of strings with ? instead of spaces because the parser breaks
Þȯᵛᵛ•CZᵗZᵛᵛ₳•c¿• would be 16 with bad formatting

C#, 341 Bytes
A naïve implementation that can definitely be shortened.
s=>s=="*"?1:0;s=>{for(int i=0,j,n,l=s.Length,c=s[i].Length;i<l;++i)for(j=0;j<c;++j)if(s[i][j]!="*"){n=0;if(i>0){n+=a(s[i-1][j]);n+=j>0?a(s[i-1][j-1]):0;n+=j+1<c?a(s[i-1][j+1]):0;}n+=a(s[i][j]);n+=j>0?a(s[i][j-1]):0;n+=j+1<c?a(s[i][j+1]):0;if(i+1<l){n+=a(s[i+1][j]);n+=j>0?a(s[i+1][j-1]):0;n+=j+1<c?a(s[i+1][j+1]):0;}s[i][j]=n+"";}return s;};

Python 2, 183 bytes
def s(m):
 j=m.find('\n')+1;q='q'*j*2;m=list(q+m+q)
 for i in range(len(m)):
  if m[i]==' ':m[i]=`sum([m[k+i]=='*'for k in [-j-1,-j,-j+1,-1,1,j-1,j,j+1]])`
 return''.join(m)[j*2:-j*2]

C, 152 150 147 145 bytes
i,j,r,c;f(B,R,C)char**B;{for(i=R*C;i--;)for(j=9;j--;){char*b=B[i/C]+i%C;r=i/C+j/3-1;c=i%C+j%3-1;r<0|c<0|r/R|c/C|*b&8||(*b=16|*b+(B[r][c]==42));}}

Input is in the form of a two-dimensional array of characters, followed by the numbers of rows and columns. The result will be returned in-place.
(Mostly) Ungolfed:
i, j, r, c;
f(B, R, C) char **B; {
    for (i = R*C; i--;)
        for (j = 9; j--;) {
            char *b = B[i/C] + i%C;
            r = i/C + j/3 - 1;
            c = i%C + j%3 - 1;
            r < 0 | c < 0 | r / R | c / C | *b & 8 ||
                (*b = 16 | *b + (B[r][c] == 42));
        }
}

The approach is straight-forward — loop over each position, loop over its neighbors, and add up all the asterisks. There are two bit-level tricks:

When we're deciding if a cell is an asterisk or not, we can just check if the eights-place bit is set, because the number in the cell must be less than 8 (the maximum cell value).
We can turn a space character into a zero character by OR-ing 16.

Edit: Golfed off two bytes by using / in place of >=.
Edit: Another five bytes by reversing the direction of the loops.

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


text:
Find the super palindromes!

Consider the number 99999999. That number is obviously a palindrome.  The largest prime factor of 99999999 is 137. If you divide 99999999 by 137, you get 729927. This number is also a palindrome.
The largest prime factor of 729927 is 101. 729927/101=7227 which again is a palindrome.
The largest prime factor of 7227 is 73. 7227/73=99 which again is a palindrome.
By further dividing by the largest prime factor, you get 9, 3 and finally 1, which, being one-digit numbers, are also palindromes. Since 1 has no prime factors, the procedure ends here.
Now generalizing this observation, I define a super-palindrome as a palindrome which is either 1, or which gives another super-palindrome if divided by its largest prime factor.

Credits: https://math.stackexchange.com/questions/200835/are-there-infinitely-many-super-palindromes
Given a number N, determine if it is a super palindrome or not, and print a truthy or falsey value accordingly.
Your program should print a truthy value for these inputs:
1
101
121
282
313
353
373
393
474
737
919
959
1331
1441
2882
6446
7887
8668
9559
9779

Your program should print a falsey value for these inputs:
323
432
555
583
585
646
642
696
777
969
989
2112
3553
4554
5242
5225
5445
8080
8118
9988

Remember, this is code-golf, so the code with the shortest amount of bytes wins.

Will the input N always be a palindrome to start with?

@Sherlock9 No..

Then can you please add non-palindromes to the falsey test cases? It would clarify the specification.

Jelly, 13 12 9 8 bytes
Æf×\D⁼U$

Try it online! or verify all test cases.
How it works
Æf×\D⁼U$  Main link. Argument: n

Æf        Yield all prime factors of n, with multiplicities and in ascending order.
  ×\      Take the cumulative product.
    D     Decimal; convert each product into the array of its base 10 digits.
       $  Combine the two links to the left into a monadic chain.
      U     Upend; reverse all arrays of decimal digits.
     ⁼      Test for equality.

Mathematica, 64 bytes
And@@PalindromeQ/@FixedPointList[#/FactorInteger[#][[-1,1]]&,#]&

Unnamed function, returning True or False. Forms a list by starting at the input, then iterating the function "me divided by my largest prime factor" until the output doesn't change. (Fortunately, Mathematica now thinks the largest prime factor of 1 is 1.) Then tests whether the list entries are palindromes (yay built-ins! boo function name length!) and Ands them all together.

Neat trick (ab)using FactorInteger[1]'s oddities with FixedPoint

yeah, for once it helped! :)

Mathematica, 51 bytes
#<2||PalindromeQ@#&&#0[#/FactorInteger[#][[-1,1]]]&

Recursive anonymous function. Takes a number as input and returns True or False as output.

05AB1E, 9 8 bytes
Saved a byte thanks to Adnan.
Ò.pPDíïQ

Try it online!
Explanation
n = 7227 used as example
Ò           # prime factors with duplicates
            # STACK: [3, 3, 11, 73]
 .p         # prefixes
            # STACK: [[3], [3, 3], [3, 3, 11], [3, 3, 11, 73]]
   P        # product
            # STACK: [3, 9, 99, 7227]
    D       # duplicate
            # STACK: [3, 9, 99, 7227], [3, 9, 99, 7227]
     í      # reverse each
            # STACK: [3, 9, 99, 7227], ['3', '9', '99', '7227']
      ï     # convert to  int
            # STACK: [3, 9, 99, 7227], [3, 9, 99, 7227]
       Q    # check for equality
            # STACK: 1
            # implicit output

I think Ò.pPDíïQ also should work.

.p can be η, and ï can be removed.

Pyth - 15 12 bytes
Beat Jelly :P :/
Unfortunately, all those implicit maps do not get shorter when combined into an explicit one since the last one is an auto-splat.
.A_IM`M*M._P

Test Suite.
Gets all the prefixes of the prime factorization, the products of which will be the intermediate super palindromes, and checks if all of them are palindromes.

Mathematica, 71 63 bytes
And@@PalindromeQ/@FoldList[1##&,Join@@Table@@@FactorInteger@#]&

Explanation
FactorInteger@#

Factor the input. (e.g. 8668 -> {{2, 2}, {11, 1}, {197, 1}}; for each list in the output, the first element is the prime factor, and the second one is the power.
Join@@Table@@ ...

For each factor-power pair, duplicate the first element by the second element, and flatten the entire thing. ({{2, 2}, {11, 1}, {197, 1}} -> {{2, 2}, {11}, {197}} -> {2, 2, 11, 197})
FoldList[1##&, ... ]

Iterate through the list, multiplying the elements. ({2, 2, 11, 197} -> {2, 2 * 2, 2 * 2 * 11, 2 * 2 * 11 * 197} -> {2, 4, 44, 8668})
And@@PalindromeQ/@ ...

Check whether all of the resulting numbers are palindromes, and apply the And operator. ({2, 4, 44, 8668} -> {True, True, True, True} -> True)

oooo, nicely done! Now I gotta go see if I can save 2 bytes somewhere....

Brachylog, 14 bytes
1|r?$ph:?r/:0&

Try it online!
Explanation
This implements the formula explained in the challenge description.
Computing all products of suffixes of the prime factorization and checking that they are all palindromes is 1 byte longer (1|$p:@]f:{*.r}a).
1                  Input = 1
 |                 OR
  r?               Reversing the Input results in the Input
    $p             Get the prime factors of the Input
      h            Take the first one (the biggest)
       :?r/        Divide the Input by that prime factor
           :0&     Call this predicate recursively with that new number as input

Racket 238 bytes
(define(p n)(=(string->number(list->string(reverse(string->list(number->string n)))))n))
(if(= n 1)#t(begin(let o((n n))(define pd(prime-divisors n))(if(null? pd)#f(begin(let((m(/ n(last pd))))
(cond[(= m 1)#t][(p m)(o m)][else #f])))))))

Ungolfed:
(define (f n)
  (define (palin? n)                      ; define palindrome of number
    (=(string->number
       (list->string
        (reverse
         (string->list
          (number->string n)))))
      n))
  (if(= n 1)#t
     (begin
       (let loop ((n n))
         (define pd (prime-divisors n))   ; find prime divisors
         (if (null? pd) #f                ; end if none- not superpalindrome
             (begin
               (let ((m (/ n (last pd)))) ; divide by largest prime divisor
                 (cond                    ; test quotient
                   [(= m 1) #t]           ; end if 1: super-palindrome found
                   [(palin? m) (loop m)]  ; loop with quotient if palindrome
                   [else #f]              ; end if not palindrome
                   ))))))))

Testing:
(f 1)
(f 101)
(f 121)
(f 282)
(f 313)
(f 353)
(f 373)
(f 393)
(f 474)
(f 737)
(f 919)
(f 959)
(f 1331)
(f 1441)
(f 2882)
(f 6446)
(f 7887)
(f 8668)
(f 9559)
(f 9779)
(f 99999999)

Output:
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t
#t

I'm not familiar with Racket, but is it neccessary that your helper function palin is  a five bytes long name?

I had corrected it earlier but it did not paste here properly. 238 bytes is with just 'p' as the name. Thanks for pointing out.

J, 30 bytes
0:`(%1>.{:@q:)@.((-:|.)@":)^:_

Error for falsey, 1 for truthy.
Initial attempt, does not error for falsey, 40 bytes:
0:`(([:$:]%{:@q:)`[@.(1&=))@.((-:|.)@":)

Explanation
0:`(%1>.{:@q:)@.((-:|.)@":)^:_
                           ^:_  repeat until convergent
              @.((-:|.)@":)     if the number is palindromic:
   (         )                   do the stuff inside, which is a 4-train
        {:@q:                    largest prime factor
     1>.                         (or 1, if smaller than 1)
    %                            divide the original number by this value
0:`                             otherwise, return 0
                                (because of ^:_, this will be passed into q:, which will
                                error because 0 cannot be factored.)

Test cases
   NB. collect errors; 0 if errored, otherwise the result of the function
   NB. left arg: values; right arg: boxed name of function
   errors =: 4 : 0
    f =. y`:6
    l =: ''
    for_e. x do.
        try.
            l =. l , f e
        catch.
            l =. l , 0
        end.
    end.
    l
)
   s =: 0:`(%1>.{:@q:)@.((-:|.)@":)^:_
   t =: 1 101 121 282 313 353 373 393 474 737 919 959 1331 1441 2882 6446 7887 8668 9559 9779
   f =: 323 432 555 583 585 646 642 696 777 969 989 2112 3553 4554 5242 5225 5445 8080 8118 9988
   t ,. f
   1  323
 101  432
 121  555
 282  583
 313  585
 353  646
 373  642
 393  696
 474  777
 737  969
 919  989
 959 2112
1331 3553
1441 4554
2882 5242
6446 5225
7887 5445
8668 8080
9559 8118
9779 9988
   (t ,. f) errors"1 0 <'s'
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0
1 0

아희(Aheui), 309 bytes (100 chars * 3 bytes + 9 newlines)
방빩반룸있쁏멐솔쌀잌
앟놂숙참뿔썁썸뻙솝셜
본서번분번뮴딸냥별쀼
슉눇번낢퉅쑫썬쌀본묳
뽇서본석첫삭뽑롷떵춤
분촐럶사눙읽숟뗘분뻨
듐삭빶쏘윙잉썩손뵬괆
쌰뭉쇼텰궮변번첳웅텩
뽇흶아희쾯볻훼윺엄솝
코드골프욉쁍숙쌉삼쏩

I'm so happy that I actually finished it!
I'm new to this language, so any tip on improving byte count is welcome.
Try it here! (copy and paste the code)
Cleaner version
방빠반루ㅇ쀼머솔쌀이
아노숙차뿌썁썸뻐솝셜
본서번분번뮤따냐별쀼
슉누번나투쑫썬쌀본묘
뽀서본석처삭뽀로떠추
분초러사누이숟뗘분뻐
듀삭빠쏘ㅇ이썩손뵬ㅇ
쌰뭉쇼텨이변번처우텨
뽀희ㅇㅇㅇ볻ㅇ유어솝
ㅇㅇㅇㅇㅇㅇ숙쌉삼쏩

What's the difference between the normal version and the clearner one?

@Oliver The first version has no NOPs (ㅇ) and has more complex characters (They are identical code; I only made the first one look more esoteric). The second version is for those who would like to actually read the program, without all the gibberish.

Husk, 9 7 bytes
ΛS=↔G*p

Try it online!
-2 bytes from Jo King.

You don't need the d, which lets you beat Jelly

@JoKing This changes a lot of my answers. I never knew numbers were reversible!

Actually, 29 bytes
There are probably several sections of this code that could be golfed, though I'm not sure where yet. Golfing suggestions welcome. Try it online!
╗1`X╜$;R=;╝╜yN╜\;╗1<&`╬X╜DY╛&

Ungolfing
          Implicit input n.
╗         Save n to register 0.
1`...`╬   Run the following function on the stack while TOS is truthy.
  X         Discard the previous truthy.
  ╜         Push n from register 0.
  $         Push str(n).
  ;R=       Check if str(n) == str(n)[::-1], i.e. if n is a palindrome.
  ;╝        Save a copy of (is n a palindrome?) to register 1.
  ╜yN       Get the largest prime factor of n.
  ╜\        Divide n by its largest prime factor.
  ;╗        Save a copy of n // l_p_f to register 0.
  1<        Check if 1 < n // l_p_f. This returns 0 only if n // l_p_f is 1.
  &         Logical AND (is n a palindrome?) and (is n // l_p_f > 1?).
            This quits if we have reached a non-palindrome or we have reached 1.
X         Discard the falsey that ended the previous function.
╜         Get the last value saved to register 0 (could be 1 or a non-palindrome // l_p_f)
DY        This returns 1 if register 0 was a 1, else 0.
╛&        Logical AND with register 1 (was the last n a palindrome?) to get our result.
          Implicit return.

Scala, 138 bytes
def?(n:Int):Int={val p=Stream.from(2).filter(n%_==0)(0)
if(p==n)n else?(n/p)}
def s(i:Int):Boolean=i<2||(i+"")==(i+"").reverse&&s(i/ ?(i))

Ungolfed:
def largestFactor(n:Int):Int={
  val p=Stream.from(2).filter(n%_==0).head
  if(p==n)n else largestFactor(n/p)}
def superPalindrome(i:Int):Boolean=i<2||(i+"")==(i+"").reverse&&superPalindrome(i/ largestFactor(i))

Explanation:
def?(n:Int):Int={                       //define a method for the largest prime factor
  val p=Stream.from(2).filter(n%_==0)(0)  //find the first factor of n
  if(p==n)n else?(n/p)                    //if it's n, return n else the next factor
}
def s(i:Int):Boolean=                     //method for the superprime
  i<2                                     //if s<2 return true
  ||                                      //else return:
    (i+"")==(i+"").reverse                  //is i a palindrome
    &&                                      //and
    s(i/ ?(i))                              //is i divided by it's largestPrimeFactor a superpalindrome

JavaScript (ES6), 78 bytes
(n,d=2,p=1)=>n%d?n<2||f(n,d+1,p):[...p=p*d+''].reverse().join``==p&&f(n/d,d,p)

Recursively builds the prime factorisation prefixes and checks them for palindromicity.

Java 7, 133 bytes
int c(int a){int x=a,y=0,z=a,i=2;for(;x>0;y=y*10+x%10,x/=10);for(;z>1;i++)for(;z%i<1;z/=i);if(a<2)return 1;return y!=a?0:c(a/(i-1));}

Ungolfed
    static int c( int a ){
    int x = a , y = 0 , z = a , i = 2 ;

    for ( ; x > 0 ; y = y * 10 + x % 10 , x /= 10 ) ;

    for ( ; z > 1 ; i++ )
    for ( ; z % i < 1 ; z /= i ) ;

    if ( a < 2 )
      return 1 ;

    return y != a ? 0 : c( a / ( i - 1 ) ) ;
 }