text:
How great is your land?
In this challenge, you'll calculate how great your land is.

Write a program or function that calculates the size of your land, given a wall you have built. You're given a non-empty input string containing a set of 4 distinct characters of your choice that represent the four directions "up", "down", "left" and "right" (I'll use ^ v < > in this challenge). It's not possible to take 180 degree turns (<> or ^v), but you may cross your wall.
The way you "capture" land is by encircling it with your wall. The wall itself is also considered part of your land. A few examples will make it more clear. I'll use o for land that has been encircled by the wall, x for the wall itself, and S for the starting point of the wall, just to illustrate how the wall is built. The output should be the total size of your land (the number of o, x and S in the test cases below).
Input: >>>>
Land: Sxxxx
Output: 5

Input: <<<^^^>>>vv
Land:
xxxx
xoox
xoox
xxxS
Output: 16

Input: <<<^^^>>>v
Land:
xxxx
x  x
x
xxxS
Output: 11

Input: <
Land: xS
Output: 2

Input: >>>>>>vvvvvvvvv<<<<<^^^^>>>>>>>>vvvvvvvvvv<<<<<<<<<<<<<<<^^^^^^^^^>>>vvvvvv<<<<<
Land:
        Sxxxxxx
              x
              x
              x
              x
         xxxxxxxxx
  xxxx   xoooox  x
  xoox   xoooox  x
  xoox   xoooox  x
  xoox   xxxxxx  x
  xoox           x
  xoox           x
xxxxxx           x
  x              x
  x              x
  xxxxxxxxxxxxxxxx
Output: 101

Input: >>vvvv>>^^<<<<^
Land:
Sxx
xox
xxxxx
  xox
  xxx
Output: 17

Input: <<^^^>>>vv
Land:
xxxx
x  x
x  x
xxS
Output: 11   <- Note, diagonal edges do not close the "loop"

Clarifications:

You do not need to draw the wall, the output should only be an integer
The input format is optional. You may take a string with <>^v, a list of digits, (1, -1, i, -i), a list of characters ABCD etc.

This is code-golf so the shortest code in each language wins. Remember, explanations are important, even in "regular" languages!

You should change the description so that it calculates how many clovers you have enclosed :P

Somewhat related

Related?

@MatthewRoh, hmmm.

@Stewie Oh yes, that's related too

Python 2, 385 345 332 bytes
A,I,R=max,min,range
a=b=0
p=[[a,b]]
for i in input():a+=i%2*(2-i);b+=(1-i%2)*(1-i);p+=[a,b],
k,l=zip(*p)
x=A(k)-I(k)+3
y=A(l)-I(l)+3
o=[[1]*y for _ in' '*x]
def g(m,n):
 if 0<o[m][n]and[m+I(k)-1,n+I(l)-1]not in p:o[m][n]=0;[g(i,j)for i in R(A(0,m-1),I(x,m+2))for j in R(A(0,n-1),I(y,n+2))if(i,j)!=(m,n)]
g(0,0)
print sum(map(sum,o))

Try it online! or Try all test cases
Input is numerical, 0~3, the 0-index of the symbols here: >v<^
#starting position
a,b=0
#new list to hold the wall coordinates
p=[[a,b]]

#iterate over the input calculating
#the next coordinate and storing on p
for i in input():
 a=a+i%2*(2-i)
 b=b+(1-i%2)*(1-i)
 p+=[[a,b]]
#i%2*(2-i) and (1-i%2)*(1-i) generate the increment
#of each symbol from last position
# >/0 : (0,1)
# v/1 : (1,0)
# </2 : (0,-1)
# ^/3 : (-1,0)

#transpose the coordinate list
k,l=zip(*p)
#calculate the difference between the max and min values
#to generate the total land size
#adding a border to avoid dead-ends
x=max(k)-min(k)+3
y=max(l)-min(l)+3

#create a matrix of 1's with the total land size
o=[([1]*y) for _ in ' '*x]

#recursive function that sets a cell to 0
#and call itself again on all surrounding cells
def g(m,n):
 #correct the indexes (like negative ones)
 a,b=m+min(k)-1,n+min(l)-1
 #if this cell contains 1 and don't belong to the wall
 if o[m][n]>0 and (a,b) not in p:
  #sets to 0
  o[m][n]=0
  #call again on surrounding cells
  for i in range(max(0,m-1),min(x,m+2)):
   for j in range(max(0,n-1), min(y,n+2)):
    if (i,j)!=(m,n):g(i,j)

#call the recursive function o origin
g(0,0)
#print the sum of the cells
print sum(map(sum,o))

This is the resulting matrix:
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Octave, 83 85 83 79 bytes
@(p)nnz(bwfill(accumarray([real(c=cumsum([0;p])) imag(c)]+nnz(p)+1,1),"holes"))

Try it on Octave Online!
A function that takes as input a column vector containing (1, -1, i, -i)
Using approach of @lanlock4 's Mathematica answer adding length of the input to coordinates to avoid non positive coordinates, instead of subtracting min of coordinates from them. Saved 4 bytes.
Previous answer:
@(p)nnz(bwfill(accumarray((k=[real(c=cumsum([0;p])) imag(c)])-min(k)+1,1),"holes"))

Try it on Octave Online!
Changed for better visualization.
Explanation:
%compute position of walls
c= cumsum([0;p]) % p should be top padded with a 0
row = real(c);
col = imag(c);
k = [row col];

%offset positions so all positions become positive
pos = k - min(k) +1;
%create a binary array that is 1 for walls and 0 elsewhere
bin = ~~accumarray(pos,1);

        *******
              *
              *
              *
              *
         *********
  ****   *    *  *
  *  *   *    *  *
  *  *   *    *  *
  *  *   ******  *
  *  *           *
  *  *           *
******           *
  *              *
  *              *
  ****************

%use flood fill to fill holes
filled = bwfill(bin, 'holes');

        *******
              *
              *
              *
              *
         *********
  ****   ******  *
  ****   ******  *
  ****   ******  *
  ****   ******  *
  ****           *
  ****           *
******           *
  *              *
  *              *
  ****************

%count number of ones in the filled image
result = nnz(filled)

Haskell, 579 530 bytes
y=length
i=filter
u i e l=take i l++[e]++drop(i+1)l
k v(r,c)g=u r(u c v(g!!r))g
b(r,c)g=g!!r!!c
w(r,c)s g=case s of{""->j;'<':t->w(r,c-1)t j;'>':t->w(r,c+1)t j;'v':t->w(r+1,c)t j;'^':t->w(r-1,c)t j}where j=k 2(r,c)g
e[]v g=g;e(x:d)v g|elem x v||b x g/=1=e d v g|b x g==1=e(d++(i(\x->notElem x v)$i(\(r,c)->r>=0&&c>=0&&r<y g&&c<y(g!!0))$a x))(x:v)(k 0 x g)
a(r,c)=[(r+1,c+1),(r+1,c),(r+1,c-1),(r,c+1),(r,c-1),(r-1,c+1),(r-1,c),(r-1,c-1)]
m s=(y.i(/=0).concat.e[(0,0)][])(w(l+1,l+1)s(map(\_->map(\_->1)q)q))where l=y s;q=[0..2*l+2]

m is the main function, which takes a string over v^<>, and returns the appropriate integer.
Ungolfed:
import Data.Set hiding (map, filter)

-- Generate a grid full of ones, of width and height 2x+1. We pass the length of
-- the input, and get back a grid that we could never go out of bounds from,
-- even when the input is a straight wall in any direction.
genGrid :: Int  -> [[Int]]
genGrid x = map (\_->map(\_->1) [0..2*x+2]) [0..2*x+2]

-- Update the value of a list l, such that index i now contains the value e
update :: Int -> a -> [a] -> [a]
update i e l = take i l ++ [e] ++ drop (i+1) l

-- scale update to two dimensions
set :: a -> (Int, Int) -> [[a]] -> [[a]]
set val (r,c) g = update r (update c val (g !! r)) g

-- index into a 2D array
at :: (Int, Int) -> [[a]] -> a
at (r,c) g = g !! r !! c

-- Walk the wall path. Replace any 1 we step on with a 2. Start walking from
-- given coordinates, recursively updating the spot we step on as we process
-- the input string.
walk :: (Int, Int) -> String -> [[Int]] -> [[Int]]
walk (r,c) s g = case s of
    "" -> set 2 (r,c) g
    '<':t -> walk (r,c-1) t (set 2 (r,c) g)
    '>':t -> walk (r,c+1) t (set 2 (r,c) g)
    'v':t -> walk (r+1,c) t (set 2 (r,c) g)
    '^':t -> walk (r-1,c) t (set 2 (r,c) g)

-- Given an input string, generate a grid of appropriate size and walk out the
-- wall path starting at the center.
sketch :: String -> [[Int]]
sketch s = let l = length s in walk (l+1,l+1) s (genGrid l)

-- Breadth-first exploration of the 2D grid, but do not pass through walls.
-- Will touch everything that's not part of the land, and mark it as not part
-- of the land. We use a set (a list in the golfed version) to keep track
-- of which coordinates we've already explored.
explore :: [(Int, Int)] -> Set (Int, Int) -> [[Int]] -> [[Int]]
explore [] v g = g
explore (x:cs) v g
    | member x v  = explore cs v g
    | at x g == 2 = explore cs v g
    | at x g == 0 = explore cs v g
    | at x g == 1 =
        explore (cs ++ (filter (\x-> notMember x v) $ filtBound g $ adj x))
            (insert x v) (set 0 x g)

-- Count everything marked as land to get the final total
countLand :: [[Int]] -> Int
countLand = length . filter (/=0) . concat

-- for a given list of coordinates and a 2D grid, filter those coordinates that
-- are within the grid's bounds
filtBound :: [[Int]] -> [(Int, Int)] -> [(Int, Int)]
filtBound g = filter (\(r,c) -> r >= 0 && c >= 0 && r < length g && c < length (g !! 0))

-- Given a coordinate, get all the adjacent coordinates, including diagonally
-- adjacent coordinates.
adj :: (Int, Int) -> [(Int, Int)]
adj (r,c) = [(r+1,c+1),(r+1,c),(r+1,c-1),(r,c+1),(r,c-1),(r-1,c+1),(r-1,c),(r-1,c-1)]

-- The main function
runMain :: String -> Int
runMain = countLand . explore [(0,0)] empty . sketch

-- Print a grid (for debugging & REPL convenience)
printG :: [[Int]] -> String
printG = concat . map ('\n':) . map show

Mathematica, 124 bytes
You probably won't be surprised to learn that Mathematica has a built-in function for measuring the area encircled by a wall. Unfortunately, it's quite bytey: ComponentMeasurements[..., "FilledCount", CornerNeighbors -> False].
With that in mind, here's my full answer. It's a function that takes a list of 1, i, -1 or -i:
1/.ComponentMeasurements[SparseArray[{Re@#,Im@#}&/@FoldList[#+#2&,2(1+I)Length@#,#]->1],"FilledCount",CornerNeighbors->1<0]&

Explanation:

FoldList[#+#2&,2(1+I)Length@#,#] builds the wall by starting at coordinate 2(1+i)(length of wall) and successively adding the elements of the input list. (We have to start at the ridiculously large coordinate 2(1+i)(length of wall) to ensure that the wall coordinates stay positive, otherwise things break.)
SparseArray[{Re@#,Im@#}&/@...->1] turns these coordinates from complex numbers to pairs of integers, and makes an array with 1s where the wall is and 0s elsewhere.
1/.ComponentMeasurements[...,"FilledCount",CornerNeighbors->1<0]& uses built-in Mathematica magic to measure the area enclosed by the wall.

"We have to start at the ridiculously large coordinate..." good trick!

PHP>=5.6.2, 888 Bytes
Online Version
<?$h=$v=0;
s($v,$h,S);
for($z=0;$z<strlen($i=$_GET[0]);){
2<($b=$i[$z++])?$h--:($b>1?$v++:($b?$h++:$v--));
$e=max($h,$e);
$w=min($h,$w);
$n=min($v,$n);
$s=max($v,$s);
s($v,$h,X);}
$f=($e-$w+1)*($s-$n+1);
ksort($a);
function i($v,$h){global$a;return isset($a[$v][$h])&&$a[$v][$h]==" ";}
function s($v,$h,$l=" "){global$a;$a[$v][$h]=$l;}
function c($v,$h,$n=1){global$a;
foreach($r=range(-1,$n)as$i)
foreach($r as$j)
if(($i+$j)&&i($v+$i,$h+$j)){if($n)s($v,$h);return 1;}return;}
foreach($a as$v=>$z){
foreach(range($w,$e)as$h){
if(!isset($a[$v][$h])){
if(($v==$s)||($v==$n)||($h==$e)||($h==$w)||c($v,$h,0))s($v,$h);
else$c[]=[$v,$h];}
}ksort($a[$v]);}
while($z){$z=0;
foreach($c as$b=>$w){if(c(...$w)){$z++;unset($c[$b]);}}};
foreach($c as$b=>$w)$a[$w[0]][$w{1}]=O;
foreach($a as $k=>$v){ksort($a[$k]);$g.=join($a[$k])."\n";}echo $g;
echo $f-substr_count($g," ");

You know you only had to output the size of the land, not the land itself right? :)

@StewieGriffin this is the output ´echo $g;` of the land. I found this approach and maybe it exists an other shorter way. If I found this way I can improve this post


text:
Rearrangeable Code Bowling
Code-Bowling Challenge
Write a program or function that produces the same output, no matter how you re-arrange the source code. (Output can't be an error)

Pangram Scoring

Your score is the amount of unique characters in your source code.

A program with source code AJB would have a score of 3
  A program with source code AAJ would have a score of 2
  A program with source code 111 would have a score of 1

This is a code-bowling variant. The program with the highest
score wins!

(For your convenience an automated scoring tool has been created here)

Challenge Rules

Input
The program/function can take an input, that's entirely optional though.
Output
This output can be anything you want, but it should be non-nil, non-null, non-empty, and non-error. (Therefor output must be at least 1 byte)
Rearrangement
No matter how the source code is re-arranged, the output should be the same. Example:
   Program: ABJ outputs hello world, as does programs: [AJB, JAB, JBA, etc.]

This is a code-bowling variant. The program with the highest number of characters wins!

Must output be in stdout, or could it be a place in memory?

Without any specific task to achieve, this challenge is too broad in my opinion.

Is "non-nil" the same as non-zero, or is the literal zero output allowed?

@JonathanAllan Edited in, output must be at least 1 byte.

@Dennis I feared requiring a specific output might make it too narrow (If that's a thing haha). The specific task is in the re-arranging of the code in my opinion.

What does non-nil mean?

@dennis by non-nil I meant it can't be empty or unassigned.  An output of "0" is fine

While your pangram scoring is an attempt to make code bowling work, I'm not sure these challenges should really be tagged [tag:code-bowling]. The scoring mechanism is quite different from what code bowling is supposed to be, so I'd say either use [tag:code-challenge] or create a new tag.

I have to agree with Martin. For example, this challenge isn't a code-golf. As soon as you score by anything besides total number of characters (or bytes), it isn't a code-bowling challenge anymore

Non-empty output is clear. What is "unassigned output"?

Does the program/function have to end? (e.g. can I print 0 forever?)

@MistahFiggins The program/function does not have to end. Printing forever is fine

@NathanMerrill Unassigned is for programs without an stdout and therefor their output is done in memory, variable assignment, or other.

@AlbertRenshaw Outputting to a variable is not an allowed output method

@NathanMerrill didn't know that, thanks!

The near-infinite scoring answers on this challenge are valid. I am really loving seeing the creative and well-bowled solutions for languages scoring under 100. If anyone has ideas for how to systematically limit near-infinite scoring answers in future code-bowling challenges, feel free to share on this meta post: https://codegolf.meta.stackexchange.com/a/11817/16513

This question is no broader than Pristine and Unique Code Bowling, or several other [tag:code-bowling] challenges. I'm not sure why it's getting close votes when they aren't.

Lenguage, 1,112,064 points if UTF-8
My program consists of every possible UTF-8 character.  It prints out "Hello world", and uses  1.75 * 1076 yottabytes of space.
(To generate the program, you simply need to make a file with 17498005810995570277424757300680353162371620393379153004301136096632219477184361459647073663110750484 characters, ensuring that each possible UTF-8 character is in the file)

You, sir, are a genius. And wait, why is my computer breaking down? :'P

I thought that Unicode had 1114112 character?

Many languages, 2 points
0.

Produces 0.0 as 0. or .0. Requires liberal number parsing that's OK with a decimal point at the start or end, assuming 0 for the missing integral or decimal part. 0000000. would give the same score.
This also works in the following languages (in some cases with a different output, as indicated):

Python REPL
Javascript REPL
MATLAB (produces ans = 0)
Octave (produces ans = 0)
MATL (produces 0)
CJam
Retina (produces 0)
Stacked (produces 0)

For Python, I think this is the only way to get a score above 1, as the possibilities can be exhausted.

Any binary or unary operator will fail as the last character
Any of [](){} require a match and will fail if the closing one comes first
A tabs or space can't start a line. Newlines can't be used in REPL.
A ,  can't be the first character
A # placed first would comment everything and produce not output
A starting \ is an invalid line continuation
Backticks (Python 2) must be paired, and them surrounding nothing is an error
$, !, ?, and @ can't be used without other unusable characters

This leaves letters, digits, _, ., and quotes.

With quotes, any non-string outside them gives an error.
Letters with possible digits and _ makes variable names, of which some permutation always doesn't exists.

The leaves digits and .. Permuting different digits gives a different number unless all the digits are 0. So, I think zeroes and . is the only way to get a score above 1. But, I don't know the Python lexer well, so I could be missing something.

CJam, score 15
T U
V	LMOQR[]0q

Try it online!
Always prints 0000:

0 just pushes a zero.
T, U, V are variables which are pre-initialised to zero.
L, M, O, Q, R are variables which are pre-initialised to an empty list, so they don't show up in the output.
[ and ] may or may not wrap things in a list, but they don't have to be matched correctly and the output is flattened for printing anyway.
q reads the input which is empty and hence doesn't show up in the output either.
linefeed, space and tab are ignored by the parser.

This is a great answer for a language like CJam! Nice

Could a lowercase r be added accomplishing something similar to the lowercase q?

@AlbertRenshaw you can't have both of them, because one will error out on EOF.

MATL, 3 5 6 points
The idea to add whitespace was taken from Bijan's answer.
lv
 T1

The code, or any permutation thereof, outputs three ones separated by newlines.
Try it online!
Explanation

Function l by default pushes number one to the stack.
Literal 1 does the same.
Literal T pushes true,  which is displayed as number one.
Space and newline are separators, and here do nothing.
v concatenates the whole stack so far into a column vector. So for example v after T would concatenate the first two numbers into a column (and then the next number would be pushed). An initial v would produce an empty array.

At the end of the code, the stack is implicitly displayed, with the following rules:

Each element or array in the stack is displayed on a different line.
Column vectors are displayed with each element on a different line.
The empty array causes no output.

So any permutation of the input characters produces 1 three times in different lines.

Explanation? I am curious about how this works.

@Sparkle Added an explanation

Nice! Also just wanted to note that I had this text in the challenge Removing any part of the source code however should cause that specific output to not be produced. at the time you posted, I did not mean to have it added and it has been removed. Maybe that will help you increase score a tad possibly

@AlbertRenshaw Thanks for the heads-up! Two more points

I'm accusing you of stealing my idea. It's not a problem though.

@Bijan Indeed. I'm already mentioning that in my answer

Jelly, score 53 101
¶ ¤$¥&+ABDFHNPQSUVX^_aborv|®²×ȧȯḄḅḌḞḢḤḷṀṂṚṛṠṢṪẠạị«»()kquƁƇƊƑƘⱮƝƤƬƲȤɓɗƒɦƙɱɲƥʠɼʂƭʋȥẸẈẒẎŻẹḥḳṇọụṿẉỵẓḋėġṅẏ

Using only characters that are part of Jelly's code-page.
Jelly has implicit input of 0, and the first half (up to and including ạị«») of the string of code above consists mostly of monadic (uppercase) and dyadic (lowercase and symbols) atoms that when given a zero or a list containing only one zero (or two such inputs in the case of dyads) return a zero or a list containing only one zero.
The exceptions are:

The space: it is ignored (even though it is in the code-page).
The pilcrow, ¶ separates links (as does a line feed - but that is really the same byte), but no other bytes will reference the code before it anyway.
the scarab, ¤, instructs the parser to treat everything to it's left starting at a nilad (or constant) as a constant (and works as a first atom).
the Dollar, $, instruct the parser to treat the two links to it's left as a monad (and, somewhat surprisingly, works as a first atom)
the Yen, ¥, similarly instructs the parser to treat the two links to it's left as a dyad.
The recommended, ®, recalls the value of the registry, initially 0 (it's counterpart copyright, ©, breaks when used as the very first atom as it is arity is found from the arity of the link to it's left, which is not yet set).

The code from the parentheses, ( and ) and on, are currently unused code points, these all get parsed and each causes a new chain (much like a newline would, although they don't have the effect of creating callable links like a newline, but that's no problem here as nothing tries to do so).

You can add all characters outside the code page for free, as the interpreter drops them before processing the code. I still don't know what non-nil means though.

I think the spirit of the challenge is probably that characters should be on-page. I asked about non-nil and the response was to specify a minimum output of 1-byte.

@Dennis any idea about the correct terminology for what hapens with the parsing at parentheses?

All unused characters begin a new link, just as a newline.

@Dennis, yet one cannot seem to "call" the chain to the left of a ( like one can with a newline (they actually seem to break things a little)

Let's call them undefined behavior. :P

TI-Basic (83 series), 93 points (99 on a TI-84 Plus)
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZθnπeiAnsrandgetKeyZXsclZYsclXsclYsclXminXmaxYminYmaxTminTmaxθminθmaxZXminZXmaxZYminZYmaxZθminZθmaxZTminZTmaxTblStartPlotStartZPlotStartnMaxZnMaxnMinZnMinΔTblTstepθstepZTstepZθstepΔXΔYXFactYFactTblInputNI%PVPMTFVP/YC/YPlotStepZPlotStepXresZXresTraceStep

All the digits, all the one-byte variables (including θ and n, the independent variables for polar and sequential graphing), the constants π, e, and i, some not-quite-variables (Ans, rand, and getKey), and 59 different window variables (all the ones that are guaranteed to be defined).
Implied multiplication guarantees that the result will be 0 when we take this in any order. If this is running on a fresh calculator, all the variables will be 0; even if not, getKey will be 0 because there's no time to press a key before the program returns a value.
On a TI-84 Plus or higher, we can get 6 more points by adding the tokens getDate, getTime, startTmr, getDtFmt, getTmFmt, isClockOn. The result will now always be {0 0 0} because getDate and getTime return lists of length 3  and the implied multiplication distributes over the elements.
I think these are all the possible tokens to use: any actual commands are prefix, infix, or postfix (meaning they won't work at the beginning or end of the program) and any other variables might be undefined (and cause an error when used).

This is clever. Not particularly impressive haha, but clever indeed! +1

(non-competing) Brainf-ck, 63 bytes
Well, I don't know if this is considered cheating, but...
.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789

The dot prints the current character (0x00) and the rest of the characters do nothing. This could technically be expanded infinitely, so please let me know if this is considered cheating.

I'd consider that a nil output

Oh, should I delete my answer then or mark it as non-competing?

There are 97 typeable characters, 7 of which you can't use (8-1), so I'd say 90.

@brianush1 you can leave it as non-competing so others can see. I'll edit question a little further to explain output must be at least 1 byte

@AlbertRenshaw (sorry for all these comments) If output must be 1 byte, then the NULL character should count, as it is a byte, although one with a value of 0.

@Bijan At least > can be used, and possibly < as well if we allow the tape to be unbounded in both directions, so the score should be 92.

The PPCG consensus is that answers can only be marked as non-competing if the language is newer than the challenge. Marking an answer as non-competing is not an excuse to keep your answer when it does not meet the question's specs.

Haskell, 3 points
+ 1

No matter how rearranged this code always returns function which increments input.
Examples of usage in repl:
>(+ 1) 1
2
>(1+ ) 1
2
>( +1) 1
2

√ å ı ¥ ® Ï Ø ¿ , 128,234 (?) points
I arrived at 128,234 with help from @DestructibleLemon. This program uses all Unicode characters (128,237) except o,O and ł. Oddly enough, two of these are output commands.
Surely, though, no language could use all those characters, right? Well this language just ignores the commands it doesn't recognise. Problem solved.
This language will, by default, output the following:
===== OUTPUT =====

==================

which is non-nil, non-null, non-empty and non-error.
Note: if this violates some unwritten rule, notify me in the comments and I'll change this. If you know my score (assuming this is allowed), also post in the comments.

What character set does it use? utf 8? utf-16? Does it use all of unicode?

@DestructibleLemon Looking on the github page, it seems to use "CP-1252" for the encoding.

@DestructibleLemon The commands are all in CP-1252 (Windows-1252) but it will accept any Unicode character as valid syntax

Apparently, there are 128,237 unicode chars, so, you would have 128,234? https://en.wikipedia.org/wiki/Unicode#cite_note-24

According to other answers apparently there are 1,112,064 unicode, so I'm not really sure anymore

///, 1 2 points
\_

Try it online!
I have no clue how to do it in any other Turing-complete language. Of course, there is HQ9, but that just feels cheaty.
1 byte thanks to @Martin Ender.

this should be two points not bytes

@DestructibleLemon Sorry, TIO formatting.

J, 3 bytes
 1

The chars 1, space and newline will always print 1.

Dots, 1,114,111 characters (if using unicode).
<87 dots here> Every Unicode character except NUL and . here
Explanation:
1                                           leading binary number
1010                                        010 increments the value under the pointer
1010111                                     111 prints out chr(1)

So the resulting binary string is 1010111, which converted to decimal is 87, so we need 87 dots.
Every other character is a comment, so we use every character except a NUL, because Python3 stops reading the file then, and a dot, because dots aren't comments.

Prelude, score 1,112,051
(When only considering the printable ASCII [\t\n -~], the score is 84. If we consider all Unicode code-points, the score is 1,112,051.)
!
" #$    %&'+,-./0:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

(then append all characters [\u{7f}-\u{10ffff}] after it.)
Always print 0.

Prelude is a parallel stack-based language, where the stack is pre-filled with infinite numbers of 0s.

+: Pop two values (always 0), add them (0), and push to stack.
-: Pop two values (always 0), subtract them (0), and push to stack.
#: Pop a value and discard it.
!: Pop a value and output it as a number (always 0) (spec says "character" but interpreter says "number"; either case, a byte is printed)
0: Pushes 0.
^, v, V: Pushes the top value of the previous/next parallel programs ("voices"), but the stacks of all "voices" are filled with 0, so they always push 0.
other characters: no-op.

So there are only 13 characters we need to avoid:

(, ): Unpaired parenthesis will cause error
1–9: We only want to output 0.
?: We don't want to input anything.
*: Causes very complicated consistency check for the code before and after a line consisting of a lone *. So we need to either remove the new line or remove the *. The reference implementation uses Python 2's .readline() which a "new line" could mean \r or \n. So it is better to just remove the *.

Deadfish, score 86
o.ABCDEFGHIJKLMNOPQRSTUVWXYZabcefghjklmnpqrtuvwxyz?!|[]_-();'"*&^$#@!1234567890+=<>,/\:

If that's illegal, then there's also
o

(score 1)

source: Stack Exchange

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

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

sort: votes


text:
Abbreviate an array
Goal:
Given an array of strings, create abbreviated versions of each string.
Specification:
For this challenge, an abbreviation is the first N characters of a string. For the string abc: a, ab, and abc are all valid abbreviations, while bc, and ac are not.
Given an array of strings, we want to find the shortest set of abbreviations, such that given the input and any abbreviation, you could determine which item of the input that the abbreviation was referring to.
Example:
Input: ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
We work our way through the strings starting with the first one.

Monday is only the item string with an M, so the shortest possible abbreviation is M.
Tuesday starts withT, but so does Thursday. This means that we try the string TU. Since no other strings start with that, we use TU.
Wednesday is W, Thursday is Th, and Friday is F.

More Examples:
Input: "one,two,three,four,five,six,seven"
Output: "o,tw,th,fo,fi,si,se"

Input: "red,orange,yellow,green,blue,purple"
Output: "r,o,y,g,b,p"

Input: "a,ab,abc"
Output: Not valid! No abbreviation for `a` that doesn't apply to the other items.

Notes:

You make input and output in any reasonable way.
You can assume that input will always be a valid array of strings.
You can assume that there will always be a solution, unlike in the last test case.
Strings will only consist of printable ASCII (or the printable characters in your encoding)
This is code golf, so fewest bytes win!

Related: 1, 2, 3

Possible duplicate of Golf Down the PPCG Usernames

I don't think it's a duplicate of any of those (although they're all fairly similar). Actually, I think this is probably the best challenge among the four; the others all have variants which make them needlessly complicated.

We can use functions, right?

@Mr.Xcoder Of course (allowed by default)

Is "" a valid input? >:)

@ØrjanJohansen No, because it is not array of strings.

I mean [""] of course, just using the obvious notation from your example list.

@Ørjan Johansen Strings plural

Ah, thanks. Although alas I just found a better algorithm that doesn't depend on this...

Is case important? In particular, your weekday example uses a capital U for Tuesday, but a lowercase h for Thursday.

Could we take a set of items?  I would normally consider it a reasonable input method, however the specifications do not indicate anything about the uniqueness of the elements.

@WheatWizard That should be fine.

@Mego Don't edit my post unless a moderator will mark it as not a duplicate

@JulianLachniet That's not how duplicates and moderators work, and arguing whether or not your post is a duplicate belongs in the comments or in chat, not in the post itself.

@Mego SE tells me that I need to edit my post to prove it's not a duplicate. Once I did, you just reverted my edit without explanation.

@JulianLachniet The duplicate tips don't really make sense for PPCG. It's an unfortunate side effect of PPCG not being a Q&A site.

@Okx I do not see the reason this is a dupe. Even if this is closely related, doesn't always mean it is a duplicate. Thus, I am leaving it open.

Retina, 29 bytes
!ms`^(.+?)(?!.+^\1)(?<!^\1.+)

Input and output are linefeed-separated lists of strings.
Try it online! (Test suite with comma-separation for convenience.)
Explanation
This simply matches all the prefixes with a single regex and prints them (!). m and s are the usual regex modifiers to make ^ match line beginnings and . match linefeeds.
^(.+?)      # Match the shortest possible prefix of a line and capture
            # it in group 1.
(?!.+^\1)   # Make sure that this prefix does not show up in a line after
            # the current one.
(?<!^\1.+)  # Make sure that this prefix does not show up in a line before
            # the current one.

Python 2, 87 86 bytes
lambda a:[b[:min(i for i in range(len(b))if sum(s[:i]==b[:i]for s in a)<2)]for b in a]

Try it online!

lambda a:[[b[:i]for i in range(len(b))if sum(s[:i]==b[:i]for s in a)<2][0]for b in a] for 85 bytes

replacing len(b) with 4**8 saves 2 more bytes, assuming that strings will be no longer than 65536 characters

JavaScript (ES6), 81 78 74 70 bytes
Takes input as an array of strings.
a=>a.map(s=>[...s].reduce((y,c)=>a.some(x=>x!=s&!x.indexOf(y))?y+c:y))

Formatted and commented
a =>                          // given an array of strings 'a'
  a.map(s =>                  // for each string 's' in 'a':
    [...s].reduce((y, c) =>   //   starting with 'y' = first character of 's',
                              //   for each subsequent character 'c' of 's':
      a.some(x =>             //     if we find a string 'x' in 'a' such that:
        x != s &              //       - 'x' is different from 's'
        !x.indexOf(y)         //       - and 'y' appears at the beginning of 'x'
      ) ?                     //     then:
        y + c                 //       append 'c' to 'y'
      :                       //     else:
        y                     //       keep 'y' unchanged
    )                         //   end of reduce(): returns the correct prefix
  )                           // end of map()

Test cases

let f =

a=>a.map(s=>[...s].reduce((y,c)=>a.some(x=>x!=s&!x.indexOf(y))?y+c:y))

console.log(JSON.stringify(f(["Monday","Tuesday","Wednesday","Thursday","Friday"])))
console.log(JSON.stringify(f(["one","two","three","four","five","six","seven"])))
console.log(JSON.stringify(f(["red","orange","yellow","green","blue","purple"])))

70 too, but absolutely other: http://codegolf.stackexchange.com/a/113270/32091

Jelly, 14 bytes
;\w@þ=1Si1⁸ḣð€

Try it online!
How it works
;\w@þ=1Si1⁸ḣð€  Monadic link. Argument: A (string array)

            ð   Collect all links to the left into a chain (arity unknown) and
                begin a dyadic chain.
             €  Map the previous chain over A. The current chain is dyadic and the
                mapped one inherits its arity. Thus, the right will be A for all
                invocations, while the left argument will iterate over A.
                For each string s in A, the following happens.
;\                Cumulative reduce by concatenation; yield all prefixes of s.
  w@þ             Window index swapped table; for each string t in A and each
                  prefix p of s, find the index of the substring t in p.
                  The first index is 1; 0 means not found.
     =1           Compare the indices with 1, returning 1 iff t begins with p.
       S          Sum the Booleans across columns, counting the number of strings
                  in A that begin with a given prefix.
        i1        Find the first index of 1, the shortest prefix that is unique
                  across all strings in A.
          ⁸       Head; truncate s to the computed length.

Haskell, 48 bytes
[_]#x=""
a#(c:y)=c:[z|d:z<-a,c==d]#y
f=map=<<(#)

Try it online!

f is the main function, taking a list of Strings and returning a String. Its definition is a monadic shortcut for f a=map (a#) a.
a#x looks at the string x and the list a and tries to find the shortest prefix of x that is unique in a. If a has a single element, just use the empty string. If a isn't already a single element, chop off the first character of x, filter and chop the elements of a starting with the same character, then recurse.

Mathematica, 64 bytes
#&@@@StringCases[#,Shortest@x__/;Tr@Boole@StringStartsQ[#,x]<2]&

Jelly, 14 12 bytes
ḣ€JṙLḶ$ḟ/€Ḣ€

Try it online!
How it works
ḣ€JṙLḶ$ḟ/€Ḣ€  Main link. Argument: A (string array)

  J           Yield the 1-based indices of A, i.e., [1, ..., len(A)].
ḣ€            Head each; for each string s in A, take the first 1, ..., and len(A)
              characters. This builds the 2D array of prefixes of all strings in A.
    LḶ$       Length-unlength; yield [0, ..., len(A)-1].
   ṙ          Rotate the 2D array 0, ..., and len(A)-1 units to the left.
       ḟ/€    Reduce filterfalse each; for each rotation, remove all prefixes from
              the first set that also occur in later sets.
          Ḣ€  Head each; for each rotation, keep only the shortest unique prefix.

Just wondering, why do you have 2 answers here? I like them both but I'm just wondering why you have two Jelly answers here. :)

If I have two similarly competitive approaches but sufficiently different approaches, I usually post them in separate answers.

Good point. Yeah, I was just wondering. :) That's a good idea; I usually don't have more than one approach :P

Javascript ES6, 70 chars
s=>(s+'#'+s).replace(/(\w+?)(\w*)(?=(\W(?!\1(?!\2))\w+)+$)|#.+/g,"$1")

f=s=>(s+'#'+s).replace(/(\w+?)(\w*)(?=(\W(?!\1(?!\2))\w+)+$)|#.+/g,"$1")

console.log(f("one,two,three,four,five,six,seven")==="o,tw,th,fo,fi,si,se")
console.log(f("red,orange,yellow,green,blue,purple")==="r,o,y,g,b,p")
console.log(f("one,two,three,four,five,six,seven".split`,`)==="o,tw,th,fo,fi,si,se")
console.log(f("red,orange,yellow,green,blue,purple".split`,`)==="r,o,y,g,b,p")

C++11 (MinGW), 198 bytes
#import<list>
#import<iostream>
f(std::list<std::string>l){int i,m;for(auto s:l){for(i=0,m=1;++i<s.length();)for(auto t:l)if(t!=s&&t.substr(0,i)==s.substr(0,i))m=i+1;std::cout<<s.substr(0,m)<<" ";}}

Call with:
int main()
{
    f({"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"});
}

Adding void identifier before the function should make it compile on other compilers too, thereby adding 5 bytes to the length.

It should be void f..., it does't work otherwise... + 5 bytes, unfortunately. Functions, as far as I know, need type specifiers in C++

Besides for that, outstanding approach! Golfing in C/C++ can be painful

@Mr.Xcoder It does compile on the MinGW compiler I'm using, though. So it's either a compiler extension or undefined behaviour.

I think it's about the compiler extension, on GCC it doesn't work...

So long as there's an environment in which the code works, it's valid

PHP, 131 120 119 118 bytes
Thanks @Jörg for preg_grep.
for(;a&$s=$argv[++$k];$i=+$t=!print"$t
")for(;a&$s[$i]&&1<count(preg_grep("(^".preg_quote($t.=$s[$i++]).")",$argv)););

takes input from command line arguments; prints results one line each.
Run with -nr or try it online.

may fail if input contains anything starting with -.
+15 bytes to fix: replace the second $argv with array_slice($argv,1).
yields warnings in PHP 7.1; replace a& with ""< (+1 byte) to fix.
-12 bytes if input contains no regex special chars:
Insert &($t.=$c) before && and replace ". preg_quote($t.=$c)." with $t.

breakdown
for(;a&$s=$argv[++$k];      # loop $s through arguments
    $i=+$t=!                # 3. reset $i and $t to empty
    print"$t\n")            # 2. print abbreviation
    for(;a&($c=$s[$i++])    # 1. loop $c through characters
        &&1<count(              # 3. if count==1, break loop
            preg_grep("(^"      # 2. find matching arguments
                . preg_quote(
                $t.=$c          # 1. append $c to abbreviation
            ).")",$argv)
        );
    );

non-regex version, 131 130 bytes
for($a=$argv;a&$s=$a[++$k];$i=+$t=!print"$t
")for($n=1;$n&&a&$c=$s[$i++];)for($n=$m=1,$t.=$c;a&$u=$a[$m++];)$n-=0===strpos($u,$t);

Replace the first and the last a& with ""< (+2 bytes) to fix for PHP 7.1.
breakdown
for($a=$argv;a&$s=$a[++$k];     # loop through arguments
    $i=+$t=!print"$t\n")            # 2. print abbreviation, reset $i and $t to empty
    for($n=1;$n&&a&$c=$s[$i++];)    # 1. loop through characters while $n<>0
        for($n=$m=1,                    # reset $n and $m to 1
            $t.=$c;                     # append current character to prefix
            a&$u=$a[$m++];              # loop through arguments:
        )$n-=0===strpos($u,$t);         # -$n = number of matching strings -1

completely uninteresting note:
strstr($u,$t)==$u and 0===strpos($u,$t) have the same length and the same result.

Use a real newline character (0x0A) instead of \n, it will save one byte ;).

@Blackhole Thanks; I forgot about that this time.

PHP, 127 Bytes
works not with invalid arrays
<?foreach($a=$_GET as$k=>$v)for($i=0,$c=2,$s="";$c>1;$r[$k]=$s)$c=count(preg_grep("_^".($s.=$v[$i++])._,$a));echo join(",",$r);

PHP, 132 Bytes
<?foreach($a=$_GET as$v)for($i=0,$s="";a&$v[$i];)if(count(preg_grep("_^".($s.=$v[$i++])._,$a))==1){$r[]=$s;break;}echo join(",",$r);

Online Version
151 Bytes supports special characters
<?foreach($a=$_GET as$v)for($i=0,$s="";a&$v[$i];)if(count(preg_grep("_^".preg_quote($s=substr($v,0,++$i),_)._,$a))==1){$r[]=$s;break;}echo join(",",$r);

PHP, 140 Bytes
<?foreach($a=$_GET as$k=>$v)for($i=0;a&$v[$i];)if(count(preg_grep("#^".($s=substr($v,0,++$i))."#",$a))==1){$r[]=$s;break;}echo join(",",$r);

This will fail if the input contains regex special characters. I´d have 113 bytes instead of 131 if not.

@Titus In this case I could add a preg_quote Make only 10 Bytes more

It will also fail if input contains 0. But you can save one byte with $i=+$s="".

and you can remove the count()-count() stuff: input is guaranteed to be valid (-21 bytes). I think I could fix and golf this down to 120 bytes. $_GET was a good idea!

@Titus I have not realized that only valid arrays are allowed. Yes it would fail if the string contain a zero but this had born an idea

Clojure, 118 bytes
#(reduce(partial map(fn[a b](or a b)))(for[i(range 1e2)S[(for[c %](take i c))]](for[s S](if(=((frequencies S)s)1)s))))

This works on prefixes up-to length of 1e2 but the same byte count can support up-to 1e9. i loops lengths of prefixes, S is the sequence of substrings of length i. The last for replaces those substrings with nil which occur more frequently than once. The reduction keeps the first non-nil value for each string, too bad or isn't a function so I had to wrap it.
This actually returns lists of lists of characters like ((\M) (\T \u) (\W) (\T \h) (\F)), but I guess it is acceptable. Clojure is quite verbose with strings, and subs would throw StringIndexOutOfBoundsException unlike take.
Full examples:
(def f #(reduce(partial map(fn[a b](or a b)))(for[i(range 1e2)S[(for[c %](take i c))]](for[s S](if(=((frequencies S)s)1)s)))))

(f ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"])
(f (re-seq #"[^,]+" "one,two,three,four,five,six,seven"))
(f (re-seq #"[^,]+" "red,orange,yellow,green,blue,purple"))

SQL (PostgreSQL 9.4 flavour), 219 bytes
Now for the longest answer:) I don't think this could even beat Java.  I will try to shave a few more off this.  Hoping to get rid of one of the nested queries, but don't like my chances.This assumes that there is a table that contains the strings to be worked on.  As this is SQL the order of the return is not guaranteed to be the same as the table order and in this case unlikely.  If this is a problem I will delete.
SELECT R FROM(SELECT*,RANK()OVER(PARTITION BY A ORDER BY C,N)Z FROM(SELECT*,SUM(1)OVER(PARTITION BY R)C FROM(SELECT*FROM A JOIN LATERAL(select left(A,n)R,N FROM generate_series(1,length(A))S(n))L ON 1=1)X)Y)Z WHERE Z=1

SQL Fiddle
Explanation
  SELECT *
  FROM A
    JOIN LATERAL(SELECT LEFT(A,n)R,N
    FROM generate_series(1,length(A))S(n))L ON 1=1

The innermost query uses generate_series and a LATERAL join to create rows for the string split into increasing lengths, so 'one' becomes 'o','on','one'. The number of characters in the return is also kept.
SELECT
  *,
  SUM(1)OVER(PARTITION BY R)C
FROM ( ... )X

Then we add the number of records which have the same result.  For example 'f' from four and five has 2, but 'fo' and 'fi' each have one.  The OVER statement in SQL can be quite powerful.  COUNT(*) would be the usual way, but SUM(1) gives the same result.
SELECT
  *,
  RANK()OVER(PARTITION BY A ORDER BY C,N)Z
FROM ( ... )Y

Then we rank the results for each input based on the least repetitions and characters.  ROW_NUMBER would work here as well, but is longer.
SELECT R FROM ( ... )Z WHERE Z=1;

Finally we select the lowest rank number for each word.

Pure Bash, 146 bytes
for i in $@;{ K=1;U=${i::1};((M++));L=;while [[ `for v in $@;{ ((L++));(($L!=$M))&&echo ${v::K}||:;}` =~ $U ]];do U=${i::K};((K++));done;echo $U;}

Try it online!

APL, 26 bytes
{⍵↑¨⍨1+⌈/+/¨∘.(∧\=∧≢)⍨↓↑⍵}

Explanation:

↓↑⍵: pad each string in ⍵ to match the length of the longest string
∘.(...)⍨: for each possible pair of strings, find the shared prefix:

≢: array inequality
∧: and
=: itemwise equality
∧\: and-scan (keep only the leading matches)

+/¨: sum each vector in the table, giving the length of the shared prefixes
⌈/: find the maximum value in each column
1+: add one, giving the amounts of characters needed to keep each string unique
⍵↑¨⍨: take that many characters from each string

Test:
      {⍵↑¨⍨1+⌈/+/¨∘.(∧\=∧≢)⍨↓↑⍵}'Monday' 'Tuesday' 'Wednesday' 'Thursday' 'Friday'
┌─┬──┬─┬──┬─┐
│M│Tu│W│Th│F│
└─┴──┴─┴──┴─┘
      {⍵↑¨⍨1+⌈/+/¨∘.(∧\=∧≢)⍨↓↑⍵}'one' 'two' 'three' 'four' 'five' 'six' 'seven'
┌─┬──┬──┬──┬──┬──┬──┐
│o│tw│th│fo│fi│si│se│
└─┴──┴──┴──┴──┴──┴──┘
      {⍵↑¨⍨1+⌈/+/¨∘.(∧\=∧≢)⍨↓↑⍵}'red' 'orange' 'yellow' 'green' 'blue' 'purple'
┌─┬─┬─┬─┬─┬─┐
│r│o│y│g│b│p│
└─┴─┴─┴─┴─┴─┘

PowerShell, 151 139 bytes
$x,$w=@(),$args[0];$w|%{$k=$_;$a='';foreach($l in [char[]]$k){$a+=$l;if($a-notin$x-and!($w|?{$_-ne$k-and$_-like"$a*"})){$x+=$a;break;}}};$x

Interested if there's a better way to do this. Had to use a foreach (over a |%) to be able to perform a break in the nested loop without labeling it.
Edit: 2 golfs from AdmBorkBork

I've not gone through the code directly, but surely you could use -notin instead of -not$x.contains($a) and !($w... instead of -not($w... to save some bytes, yes?

APL (Dyalog), 27 bytes
{⍵↑¨⍨1⍳⍨¨↓+/(↑,\¨⍵)∘.(⊃⍷)⍵}

Try it online!
{ an anonymous function, where ⍵ represents the argument...
 ∘.( a function table where the function is
  ⊃ the first element of
  ⍷ the Boolean list "left argument begins here in the right argument?"
 ) where the right arguments are
 ⍵ the arguemts
 ( and the left argument is
  ↑ a table with rows consisting of
  ,/ prefixes of
  ¨ each of
  ⍵ the arguments
 +/ sum across (counts how many of the arguments befin with this prefix)
 ↓ split table into list of rows
 ⍳⍨¨ in each one, find the location of the first
 1 one (i.e. the first prefix that only heads one argument)
 ↑¨⍨ for each location, takes that many characters from the corresponding element of
 ⍵ the argument
} end of anonymous function

Q, 93 bytes
{n:1;{$[any e:(,/)1<{(+/)i like x}each i:z#'x;[z+:1;y:?[e;z#'x;i];.z.s[x;y;z]];y]}[x;n#'x;n]}

Solved recursively, takes string as input, gets first n elements of each string with every recursion. If any of those elements aren't unique it replaces them with first n+1 elements.

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


text:
Is it true? Ask Jelly!
Background
Inspired by Octave's (and, by extension, MATL's) very convenient interpretation of truthy/falsy matrices, Jelly got the Ȧ (Octave-style all) atom.
Ȧ takes an array as input and returns 1 if the array is non-empty and does not contain the number 0 (integer, float, or complex) anywhere in the tree structure; otherwise, it returns 0.
For example, the array [[]] is truthy because it is non-empty and contains no zeroes, but [[0]] is falsy because it contains a 0 at the innermost level.
Task
In a programming language of your choice, write a full program or a function that takes a possibly empty, possibly jagged array of integers as input and prints or returns a truthy or falsy value that indicates if Ȧ would return 1 or 0, respectively.
Your submission must abide to the following rules.

The truthy and falsy values must be consistent for all inputs, i.e, all arrays for which Ȧ returns 1 must map to the same truthy value, and all arrays for which Ȧ returns 0 must map to the same falsy value.
Since full programs can only take string representations of arrays as input, this is allowed. However, you must use the canocical representation of your language, as returned by repr or similar.
In particular you cannot assume that the first element of the array will be preceded by a space.
If (and only if) your language cannot represent jagged arrays natively, you may take a string representation of the input, using the canonical syntax of any pre-existing programming language.
If your language has several ways of representing jagged arrays (e.g., lists and tuples), you only have to support one of them.
If your language has a built-in that is itself a valid submission to this challenge, you may not use it in your answer. All other built-ins are allowed.
You are encouraged to post answers using both array and string manipulation, even if one is significantly shorter than the other.
All standard code-golf rules apply.

May the shortest code in bytes win!
Truthy test cases
[1]
[10]
[[]]
[[[[1]]]]
[[], [1], [1, 2]]
[[1], [1, [2]], [1, [2, [3]]]]
[[8], [8, [9]], [8, [9, [10]]]]

Falsy test cases
[]
[0]
[0, -1]
[-1, 0]
[[[[0]]]]
[[0], [1, 2], [3, 4, 5]]
[[8], [8, [9]], [8, [9, [1, 0]]]]
[-1, 0, 0, 0]

Based on the test cases, do you mean "contain the number 0" to mean anywhere in the tree structure? That's not what I have guessed it meant.

Yes, anywhere. I'll try to clarify that.

What exactly do you mean "you cannot assume that the string representation will have a particular format"?

@Dada Hopefully clarified. For example, you cannot assume that there will be a space before each element, e.g., [ 0, 1] for Python.

@Dennis Yea, that sentence and the example you added clarified it, thanks

@Dennis Might the list string contain numbers like 03? That would mess up some string-based methods.

CC @xnor Only the canonical representation has to be supported, so 03 doesn't have to be supported.

Very convenient, but also very non-sensical interpretation.

These are not jagged arrays - jagged arrays would have all numbers at the same depth, because only sizes vary, not element types.

@ØrjanJohansen, Object[] is Object in most languages ;)

@Qwertiy Right, "most" languages where "everything" is an Object... my favorite is Haskell, where it isn't. Nor in C, at least not in a way that allows you to mix arrays and ints safely. Both of those languages are perfectly capable of jagged arrays, but still cannot use them for this problem.

@ØrjanJohansen On those cases, you could use string manipulation techniques :)

@MatthewRoh Not if you take the rules of this question literally. You're only allowed that if the language does not support jagged arrays natively. Which is really what my whole quibble is about - the rules don't say what they intend to say.

Would this be truthy: ["0"]

@ev3commander "takes a possibly empty, possibly jagged array of integers", so you don't need to deal with string input.

Dang it Dennis. I was going to use a builtin :P

Is it okay if we have more than one output for false?

@KritixiLithos From the spec: The truthy and falsy values must be consistent for all inputs, i.e, all arrays for which Ȧ returns 1 must map to the same truthy value, and all arrays for which Ȧ returns 0 must map to the same falsy value.

Even though C can do jagged arrays, it would be too hard, since we would need to dig pointers, so can I use a string input?

Jelly, 3 bytes
ṭFẠ

F flattens the input list.
ṭ tacks on the original input list as an element, which is falsy if and only if it is empty.
Ạ then checks if any element in the flattened list, or the original list itself, is falsy.

(Original answer)
FẠ^Ṇ

Thanks to Dennis for encouraging finding a solution matching his.
FẠ gives 0 if the input contains a falsy value at any depth, else 1. This is what Ȧ does, except for empty lists.
Ṇ gives 1 if the input is a falsy value, else 0. The only falsy list is the empty list.
XOR-ing the two gives the answer.

F;WẠ

This is much in the same spirit as Dennis's F;LẠ, but instead of using L to put a zero in the list when the list is empty, it uses W to put the empty list into itself (producing [[]]), making it contain a falsy element.

Outgolfed in my own challenge and my own language... Well done!

Retina, 10 bytes
A`\b0
^...

Try it online!
First we remove the input if it contains a zero. The we try to match at least three characters from the beginning of the string (to ensure that the input hasn't been eliminated in the previous stage, or was only [] to begin with).

Ruby, 25 24 23 18 16 bytes
p$_!~/\D0|^..$/

Requires the -n flag on the command line (+1 byte, -e -> -ne).
Try it online!
This is a full program that takes input in Ruby's canonical array format on STDIN and outputs true or false on STDOUT.
 $_              # line of input that was read automatically (-n)
   !~/        /  # does not match the regex...
      \D0        #   a non-digit followed by a 0
         |       #   or...
          ^..$   #   a 2-length string (which must be [], the empty array)
p                # output the result

23 byte function version:
->a{"#{a}"!~/\D0|^..$/}

This is a proc that takes one argument, the array to be tested.
Thanks to Martin Ender for a byte and to Ventero for two bytes!

You could save two more bytes by using p$_!~/\D0|^..$/ (or p ! ~/\D0|^..$/, yay significant whitespace) together with the -n flag.

Very late, but you can get 13 bytes using apparently undocumented behaviour of !.

05AB1E, 9 8 bytes
-1 bytes thanks to Emigna
)Q¹˜0å~_

Explanation:
)Q        Is the length of the input 0?
  ~    _  ... NOR ... (just for you, Dennis)
   ¹˜     Input deep flattened
     0å   Contains 0

Try it online!

Seems to fail for [[]].

Is 0 really truthy in 05AB1E?

all arrays for which Ȧ returns 1 must map to the same truthy value, and all arrays for which Ȧ returns 0 must map to the same falsy value (emphasis mine)

@Dennis Alright, chucked in a logical negation byte there.

Aw, just for me. :P

You could replace g0 with ).

APL (Dyalog), 21 12 7 bytes
Golfed 5 bytes thanks to Adám by using forks
⍬∘≡⍱0∊∊

Try it online!
This is my first try at Dyalog. Golfing tips are welcome!
Explanation
⍬∘≡                   Fork; Is the argument a null set
   ⍱                  Nor
    0∊∊               0 belongs to the enlisted form of the argument
                      For example, (1 (2 (3 (0)))) would become
                      1 2 3 0 using the ∊ monad
                      Then we check if zero belongs to this vector

+1 Note that you are combining the results of two tests. This is perfect for a fork. ⍬∘≡ is the left test (empty-set bound-to identical-to), and 0∊∊ is the right test (itself a fork; zero member-of enlisted-form). Put it together: ⍬∘≡⍱0∊∊. Try it online!

Also, you may want to use the name "APL (Dyalog)" so people can find what it is you are using.

Jelly, 4 bytes
FẠ_Ṇ

Try it online!
Ȧ yields 0 if the input is empty or contains a 0, otherwise it is 1.
FẠ yields 0 if the flattened input contains a 0, leaving only the edge case of an empty array (since the input is guaranteed to be an array).
Ṇ is a non-vectorising logical not monad, and hence returns 0 for any non-empty list and 1 for the empty list. As such this can simply be subtraced from the result of FẠ using _.

One down, at least one more to go.

@Dennis It isn't FẠạṆ, right?

@EriktheOutgolfer No, it is not. The answer I have in mind deals different with the edge case of an empty array and would produce a different result for non-arrays.

@Dennis Like returning A for True, B for false, C for empty and D for non-array? That would be non-competing. What I did is use absolute difference instead of difference because there are no negative booleans.

@EriktheOutgolfer B must equal C to comply with the challenge spec, but D can be anything as the input is guaranteed to be an array.

But, if I understand correctly, you seem to say that B ≠ C in your case ("deals different with the edge case of an empty array.")

Sorry, I didn't see this when I posted my own answer using ^ instead of _, otherwise I would've just commented here.

@hvd Oh, no problem. I'm still wondering what the more obscure solution is (my guess is there is no Ạ in it).

@JonathanAllan I did find two others with Ạ, one with length 4, and one with length 3. I don't know if either of those is what @Dennis had in mind.

Mathematica, 17 bytes
#!={}&&#~FreeQ~0&

FreeQ does the check against 0 for us, but of course it would return True for input {}, so we need to check that case separately.

Operation Flashpoint scripting language, 199 188 bytes
A={f={private["_i","_r"];_r=1;_i=0;while{_i<count _this}do{o=_this select _i;if(o in [o])then{if(o==0)then{_r=0}}else{_r=o call f};_i=_i+1};_r};if(count _this==0)then{0}else{_this call f}}

Call with:
[3,6,4,[4,6],[3,6,[],[2,4,[0],3]]] call A

or with:
hint format["%1", [3,6,4,[4,6],[3,6,[],[2,4,[0],3]]] call A]

Explanation:
In the game's scripting language, any string containing code can be called. The curly braces {} denote the beginning and the end of a string. (Quotation marks work too, but that gets messy when they are nested.) So, A={...} assigns a string to variable A, and the variable can then be called like a function with: <argument> call A. Basically any string can be treated as a block of code.
Then, inside the "function" A, we define another function f. private declares the two variables _i and _r local to function f. A local variable's name has to start with an underscore.
while {} do {} is a loop, where the first string (denoted by {}) contains the code for the loop condition and the second one for the loop body.
_this is the argument that was passed with the call function. _this can be of any type, but here we assume it is an array.
In the loop, o=_this select _i accesses the _i:th element of the array and assigns it to variable o. if (o in [o]) is a trick to determine if the o is another array or not.
If o is a number (or anything other than an array), o in [o] will evaluate to true, because the in function finds a value matching o from the array [o]. If o is an array, the expression yields false, because the in refuses to compare arrays.
If o is not an array, we check if it equals zero, and if it does, we'll set the variable _r, which we'll use as the return value, to zero.
Otherwise, if o is an array, we assign to _r the return value of the recursive call to f with the new array o as the argument.
After the loop, at the end of function f, we evaluate the expression _r, which yields the value of _r, and as this is the last expression to be evaluated, this is what the call to function f returns.
Now that we have defined f (f need not be inside A, but this way we could have declared it a local variable/function (no difference really) of A if we didn't want to save some bytes), let's get back A. if (count _this == 0) checks if A's input array is empty, and if it is, A returns 0. Otherwise the function f is called and its return value will be A's return value.
One might notice that it seems that a semicolon would be missing from a few of places, but this is not the case, because a semicolon is only needed after a statement if another statement follows it inside the same block of code (i.e. string).

Wait, what?! Operation Flashpoint?

wat how? what??? confuzed

@DownChristopher Added an explanation.

@AnderBiguri Yep, why not? The game's scripting language fits the definition of programming language given in the meta post linked in the question.

@Steadybox I am confused about the existence of the thing, not its validity!!

Perl 5, 15 bytes
Saved 2 bytes by using the same technique as Doorknob's Ruby answer.
14 bytes of code + -p flag
$_=!/\b0|^..$/

Try it online!
/.../ ensures that the array isn't empty (it will match on any array but [].
/\b0/ will only match if there is a 0 in the array. (the \b ensures that the 0 isn't a part of another number but a whole number).

Haskell, 48 bytes
f x=or[elem c"[,"|c:'0':_<-scanr(:)[]x]<(x<"[]")

Try it online!
Thanks to Lynn for the test cases and the x<"[]" trick.
The outer inequality requires (x<"[]") to be True (nonempty list) and or[elem c"[,"|c:'0':_<-scanr(:)[]x] to be False (no zeroes).
Characters of  0 are detected as following a , or [, as opposed to a number like 20. The expression scanr(:)[]x generates all suffices of l, and c:'0':_<- captures those whose second character is '0'. Then, elem c"[," checks whether the first character is , or [.
I assume here that Haskell-style lists don't have spaces, but if so ',' can just be replaced by ' '.
Here's a more direct 48-byte method, though it produces 0's and 1's which aren't Truthy/Falsey in Haskell.
f"[]"=0
f(c:'0':_)|elem c"[,"=0
f(_:t)=f t
f _=1

Jelly, 4 bytes
F;LẠ

Try it online!
How it works
F;LẠ  Main link. Argument: A (array)

F     Flatten A.
  L   Yield A's length.
 ;    Concatenate.
   Ạ  All; Tell if all elements of the resulting 1D array are truthy.

Note that the Ạ atom behaves like Python's all and thus is rather different from the banned Ȧ.

Heads-up: This isn't the only 4-byte solution Jelly, apart from the obvious L;FẠ. Who can find another one?

Grime, 16 14 11 bytes
Thanks to Zgarb for saving 5 bytes.
e`s\0v#|!..

Try it online!
The e tells Grime to try and match the entire input and print 0 or 1 depending on whether that's possible.
The |! is effectively a "neither" operator, because x|!y is shorthand for (x|y)!. So we make sure that the input neither contains a zero preceded by a symbol nor is a string of only two characters ([]).
A note about the second half: P# matches a rectangle that contains at least one match of P. However, in our case P consists of both s and \0 so that would normally require parentheses: (s\0)# (because the precedence of # is too high). But Grime has a really neat feature where you can modify the precedence of operators with ^ and v. So by using v# we lower #'s precedence so that it's lower than that of any other operator (including concatenation), which lets us save a byte on the parentheses.

Julia, 45 bytes
a(x)=all(a,x);a(x::Int)=x!=0;g(x)=x!=[]&&a(x)

This creates a function g that indicates whether Ȧ would be 1 or 0 by calling a recursive function a. To make a suitable a, we use multiple dispatch:
# A method for scalar values
a(x::Int) = x != 0

# A recursive fallback for arrays
a(x) = all(a, x)

The function all takes a function argument, so we're calling a on each element of the input. Then we simply define the function for the submission as
g(x) = x != [] && a(x)

Basically we just need a but with a check to correctly handle [].
Try it online!

can you define the function a(x) or g(x) as !x instead?

Haskell, 62 bytes
import Data.List
(%)=isInfixOf
f x=not(",0"%x||"[0"%x)&&x<"[]"

Try it online!
This is a function String -> Bool. Haskell’s lists are heterogenous, so there’s no built-in way to represent lists like [0, [0]].

Based on the re-worded rules, the inputs should not have spaces because Haskell arrays don't by default. At least, I think that's the interpretation even though Haskell doesn't allow jagged arrays. But it looks like your code would work the same with , for  .

As I'm quibbling up in the question comments, Haskell does have jagged arrays (and lists) - it's just that it's not really enough for what this question requires.

JavaScript (ES6), 34 bytes
a=>a.length&&+!~`,${a}`.search`,0`

Test cases

let f =

a=>a.length&&+!~`,${a}`.search`,0`

console.log('Truthy:')
console.log(f([1]))
console.log(f([10]))
console.log(f([[]]))
console.log(f([[[[1]]]]))
console.log(f([[], [1], [1, 2]]))
console.log(f([[1], [1, [2]], [1, [2, [3]]]]))
console.log(f([[8], [8, [9]], [8, [9, [10]]]]))

console.log('Falsy:')
console.log(f([]))
console.log(f([0]))
console.log(f([0, -1]))
console.log(f([-1, 0]))
console.log(f([[[[0]]]]))
console.log(f([[0], [1, 2], [3, 4, 5]]))
console.log(f([[8], [8, [9]], [8, [9, [1, 0]]]]))

You can probably use !!a[0] instead of a.length. (You don't have to worry about a[0] being zero as the result must be false in this case anyway.)

Never mind, I saw Qwerty already got there.

Wonder, 15 bytes
@&#0! iO0flat#0

Usage:
(@&#0! iO0flat#0)[1;2;3;[8;9;0]]

Flatten input, get all occurrences of 0, logical NOT, logical AND with input.

Python 2, 45 39 38 bytes
lambda a:(a>[])^(' 0'in`a`or'[0'in`a`)

Try it online!
-6 thanks to @BenFrankel

previous version, without converting list to string repr, 68 bytes:
lambda a:(len(a)and g(a))*1
g=lambda b:all(map(g,b))if b>[]else b!=0

This gives a false positive on []. The following saves 6 bytes and succeeds on []: lambda a:bool(a)^(' 0'in\a`or'[0'in`a`)`

Pip, 12 bytes
#Va&`\b0`NIa

Takes the array as a command-line argument in Pip's repr form, like [1;[2;3]]. Returns 1 for truthy, 0 for falsey. Try it online or verify all test cases.
Explanation
              a is 1st cmdline arg (implicit)
 Va            Eval a (converting from a string to a list)
#              Take the length (0 if empty, nonzero if nonempty)
   &          Logical AND
    `\b0`      Regex pattern: word boundary followed by 0 (avoids things like 10)
         NIa   Not in a (0 if `\b0` matches in a, 1 if it doesn't)
              Autoprint

Bonus answer, 12 bytes
Here's a function that takes a list instead:
#_>0=0N_Js^s

#_            Len(arg)
  >0          is greater than 0
    =         which also equals the following (comparison operators chain like Python's):
     0N       Count of 0's in
       _Js^s  arg, joined on space and then split on space (a hacky way to flatten)

TIO

Röda, 59 44 bytes
f a{[1]if{g(a)[[]!=a]}}g a{[a!=0];try a|g _}

Try it online!
f takes the input from its stream as a list that can contain other lists and integers. It returns 1 if a is truthy and nothing otherwise. The helper function g checks if a contains zeros.
Explanation:
f a{[1]if{g(a)[[]!=a]}}
f a{                  } /* Function declaration */
          g(a)          /* Call g -> pushes some booleans to the stream */
              [[]!=a]   /* Push value []!=a to the stream */
       if{           }  /* If all booleans in the stream are true: */
    [1]                 /*   Push 1 to the stream */
                        /* Otherwise return nothing */

g a{[a!=0];try a|g _}   /* Helper function */
g a{                }   /* Function declaration */
    [a!=0];             /* Push value a!=0 to the output stream */
           try          /* Ignore errors in the following if a is not a list */
               a        /* Push values in a to the stream */
                |g _    /* Pull values from the stream and */
                        /*   call g for each of them */
                        /*   (pushes boolean values to the output stream) */

A solution that makes use of regexes could very likely be shorter.
This answer could have been shorter if it were allowed to return multiple values. This has been discussed in one of my answers before, and it was concluded that it is allowed in the default rules to return different truthy and falsy values for different inputs, but for some reason OP forbid it here and there. :(

Haskell, 45
As Lynn and xnor remarked, Haskell does not come with a heterogeneously-nested list type. But it's easy to add them as a custom data type and let the function operate on that type, and this is much preferrable to operating on (urgh!) strings.
data L=L Int|T[L]
f(L n)=n/=0
f(T l)=all f l

To actually be able to write out such lists as literals with [1, [2]] syntax, you also need some typeclass fu. Full test case:
{-# LANGUAGE OverloadedLists, TypeFamilies #-}
import GHC.Exts (IsList(..))

instance Num L where
  fromInteger = L . fromInteger
  negate (L n) = L $ negate n
instance IsList L where
  type Item L = L
  fromList = T
main = mapM_ (print . f) (
                    [ [1]
                    , [[[[0]]]]
                    , [[8], [8, [9]], [8, [9, [1, 0]]]]
                    ] :: [L])

Try it online!

MATLAB, 49 bytes
As MATLAB (as well as Octave) does not allow these kind of nested arrays, we interpret it as a string.
First we replace all non-digit characters with a space. Then we use str2num to convert it to an (1D) array, on which we can apply all (which is allowed, as it does not completely solve this task by itself.)
s=input('');s(s<45|s>57)=32;disp(all(str2num(s)))

egrep, 7+3=10 bytes
\<0|^.]

+3 bytes for the required -v flag to invert the result.
Grep doesn't have any concept of arrays, so this uses a string representation as given in the question. Takes input on one line from stdin, returns via the exit code (ignore stdout).
(Now using a version which doesn't account for 01 and similar, since word-of-god is that it's OK)
Original bash/grep entry:
grep -Ev '\<0+\>|^.]'

Finds 0s anywhere (using the word boundary checks \< and \> to discount things like 10 or a1), or a whole string matching [], then inverts the match.
Breakdown:
grep
     -E \    # extended regular expression syntax
     -v \    # invert match
     \<0+\>  # a number of 0s with alphanumeric boundaries on both sides
     |^.\]   # or ']' as the second character (implies '[]')

Not cheating, just good golfing. :) Btw, grep is capable for primality testing, so it is a programming language as far as PPCG is concerned. \<0\|^.] plus -v would count as an 11 byte solution.

@Dennis cool, thanks! (I switched to egrep rather than grep to save an additional byte; language name doesn't count towards byte-count!)

Javascript ES6, 24 23 chars
Works with array, returns true or false:
a=>!!a[0]>/\b0/.test(a)

Test:

f=a=>!!a[0]>/\b0/.test(a)

console.log([
  [1],
  [10],
  [[]],
  [[[[1]]]],
  [[], [1], [1, 2]],
  [[1], [1, [2]], [1, [2, [3]]]],
  [[8], [8, [9]], [8, [9, [10]]]],
].every(x => f(x)===true))

console.log([
  [],
  [0],
  [0, -1],
  [-1, 0],
  [[[[0]]]],
  [[0], [1, 2], [3, 4, 5]],
  [[8], [8, [9]], [8, [9, [1, 0]]]],
].every(x => f(x)===false))

Since the return value can be truthy/falsy, you can drop the !! (though then you must change & to &&). Saves one byte.

@BrianMcCutchon, no as there is a binary &. In case of && without !! consistent output will be broken: undefined for [],0 for [0] and [0,1,2] and false for others.

I don't see how breaking consistent output is bad in this challenge. My point with switching to && is that you would need to if you take my first suggestion, since 2 & 1 == 0.

@BrianMcCutchon, the first point of the question: "The truthy and falsy values must be consistent for all inputs, i.e, all arrays for which Ȧ returns 1 must map to the same truthy value, and all arrays for which Ȧ returns 0 must map to the same falsy value."

Ah, I skimmed that too quickly. Never mind.

As always, &! => >

@l4m2, no, it's not.

@l4m2, opps. You are right. Now updated.

√ å ı ¥ ® Ï Ø ¿ , 12 4 bytes
i0Bu

Explanation
i            › Take input as a list and automatically flatten it. If empty, push 0.
 0           › Push 0 to the stack
  B          › Pop 0 and push the number of times it appears
   u         › convert top value to its boolean

If result needs to be outputted ...
i0Buo        › same as above; o outputs the top value on the stack

Previous solution
I had posted this before realising that stack based languages could leave the value on the stack as a form of output
i0B¿0oP?!¿o?

Explanation
i            › Take input as a list and automatically flatten it. If empty, push 0.
 0           › Push 0 to the stack
  B          › Pop 0 and push the number of times it appears
   ¿         › If the top value is true ...
    0        › Push 0
     o       › Output the top value on the stack
      P      › Pop the top value from the stack
       ?     › End if statement
        !    › Boolean opposite of top value
         ¿   › If the top value is true ...
          o  › Output the top value
           ? › End if statement

Vim, 23 bytes
:g/0\|^..$/d
:s/.\+/1/<CR>

Try it online!
Outputs an empty string for false, or 1 for true. This could be shorter if I can output an empty string or [] for false (both of which are falsy values in vim).

VIM: 16 keystrokes 28 keystrokes 26 keystrokes
Had to add a bunch of keystrokes to take care of multiple zeros and the empty array [].
i[] 0<enter><esc>A 0<esc>h#dd0%r602x<C-x>$hd0<C-a>

Expects the array to be in the first and only line of the file and the cursor to be on the first character. Leaves 0 for false and a 1 for true.
Explanation

i[] 0<Enter><esc> Writes some stuff preceding the array
A 0<esc> Writes some stuff preceding the array
#dd search for the word "0", going backwards in the document and delete the line it's containing.

If 0 is in the array, this will stop on the second line.

This leaves [] 0 on the first line, which is an empty array.

Else, this will stop on the first line, leaving the line (array) 0

At this point, all that's left to do is to identify the empty array and output 0 if it's present, otherwise ignore it.
The possible way for a 0 to be at the third position is if it is the empty array. Thus, it's just a problem for identifying if the third character is a 0.

3|a01<esc> Writes 01 after the third character
0df0 Deletes up to the first zero.
lD saves the next character, then deletes the rest of the line.

Try it online!

The program doesn't work for [-1, 0, 0, 0]

I was able to golf it smaller and detect multiple zeros, but then discovered it also currently fails for [].

Stacked, 20 bytes
:size\flat,0 eq none

Try it online!
Alternatively, using a string:
:tostr'\d+'match'0'has¬\size¬>

Try it online!

Lithp, 74 bytes
(def f #L::((foldl(flatten L)(?(>(length L)0)1 0)#N,A::((?(== N 0)0 A)))))

Try it online!
Well, this turned out longer than I'd hoped. The [] case tripped me up and added a few bytes. It simply flattens the list and does a fold left over it, and if it finds a 0 it sets the accumulator to 0.

Ruby, 24 22 bytes
->a{a[0]&&a*?!!~/\b0/}

Try it online!
Yes I know there's a better solution in Ruby but I wanted to find one taking the array in input instead of a string.

tinylisp, 70 64 bytes
(load library
(d _(q((X)(i(c()X)(all(map _ X))X
(q((L)(i L(_ L)0

The last line is an unnamed lambda function that takes a list and returns 1 for "truthy-under-Ȧ" and 0 for falsey. Try it online!
Ungolfed
(load library)

(def _Ȧ
 (lambda (val)
  (if (equal? (type val) List)
   (all (map _Ȧ val))
   val)))

(def Ȧ
 (lambda (ls)
  (if ls
   (_Ȧ ls)
   0)))

The recursive helper function _Ȧ does most of the work. If its argument is a list, we map _Ȧ to its elements and return 1 if they are all truthy, 0 if any are falsey. (Conveniently, all returns 1 when given the empty list.) Otherwise, the argument must be an integer; we return it as-is (0 is falsey and all other integers are truthy in tinylisp).
The main function Ȧ checks if the list is nonempty. If so, it calls _Ȧ; if not, it returns 0.
The golfed version takes advantage of some undefined behavior: rather than using (e(type X)List) to test whether X is an integer or a list, it does (c()X), which attempts to cons (prepend) the empty list onto X. If X is a list, this results in a nonempty list, which is truthy. If X is an integer, tinylisp outputs an error message and returns an empty list, which is falsey. Since stderr is ignored, this approach is valid.

Zsh, 19 bytes
egrep '\b0\b|^\[]$'

Try it online!
zsh doesn't have any support for nested arrays, so there is no "canonical" representation. I've used Python-style square bracket notation, but this could fairly trivially be modified for most other syntaxes.

R, 35 bytes
function(x)all(unlist(x))&length(x)

Try it online!

05AB1E, 4 bytes
gªĀß

Try it online or verify all test cases.
Explanation:
g     # Push the length of the (implicit) input-list
 ª    # Append this length to the (implicit) input-list
  Ā   # Check for each inner-most integer that it's NOT 0 (0 if 0; 1 otherwise)
   ß  # Pop and push the flattened minimum of the list
      # (after which it is output implicitly as result)

Fig, \$4\log_{256}(96)\approx\$ 3.292 bytes
AfJL

Try it online!
-3 thanks to Steffan
AfJL
  JL # Prepend the length of the input
 f   # Flatten
A    # All truthy?

This doesn't work for many test cases. You need to check all, not any.

@Steffan this outputs using inverted logic

I know. It doesn't work correctly, for example try [0, -1] which should return 1 with inverted logic.

@Steffan then the testcases are wrong? the challenge says "does not contain the number 0 (integer, float, or complex) anywhere in the tree structure;"

Sorry, [0, -1] produces correct output. [0] and [] do not, though.

@Steffan they both produce the correct result of 1. try adding another ! to the start of the program to use normal truthiness :)

Oof sorry I'm getting confused. [0, -1] should produce 1 (false) but produces 0.

Here's a test case link. It should be an array of 0s then 1s.

Let us continue this discussion in chat.

Vyxal r, 3 bytes
fpA

Try it Online!
I don't think there's a flagless 3-byter. Tons of 4-byters though.

CJam, 10 9 bytes
-1 byte by replacing #) with &
_,\e_0&!&

Try it online!
Link includes all test cases
Explanation
_,\e_0&!& # function
_,        # dup and push the length of the input array
  \e_     # flatten the input array
     0&   # AND the array with 0, essentially check if 0 in list
       !  # logical negate (0 IS in list => returns 0, 0 is NOT in list => returns 1
        & # bitwise AND (of the length and the 0 check)

CJam, 12 bytes
l~a_e_+:e&!!

Try it online! or verify all test cases
Explanation
l~            e# Read and eval a line of input
  a           e# Wrap the array in an array
   _          e# Duplicate it
    e_        e# Flatten it
      +       e# Concatenate; results in adding the input array to the beginning of itself
       :e&    e# Reduce the array using logical AND: if any element of the array is falsy,
              e#   the result will be that falsy element, otherwise a truthy element
          !!  e# Double negation (coerce to boolean)

QBIC, 41 bytes
;?-(_lA|<3)+instr(A,@[0`)+instr(A,@,0`)=0

Maybe it's time to put instr on the to-do list...
Explanation:
;                   Get a string from the cmd line
 -(_lA|<3)          Check the length ( _lA| ) and yield 0 for
                    strings longer than 2, 1 for shorter ones;
                    this checks for the empty array []
 +instr(A,@[0`)     Then check if the string "[0" is present,
 +instr(A,@,0`)     or the string ",0"
                    If any of the above is true, these statements give a 1.
                    Those are summed: invalid arrays have a sum > 0
?              =0   Print a -1 for 'true' arrays, and '0' for false.

QBIC cannot do a list-based version of this challenge.

Pyth, 9 Bytes
!|/.nQ0!l

Takes an array and outputs True or False.
The double ! (Not) is needed so that the output is consistently true or false.
Explanation:
!|/.nQ0!l
        l     - The length of the input array (input implicit on the right)
       !l     - Negate it: True if 0 else False
     Q        - Evaluate the input string to a array
   .nQ        - flatten the array
  /   0       - How often does 0 appear?
 |            - logical OR: If zero does appear return True else the length of the array
!             - Negate the result

Try it online!
more boring same length alternative:
!|}0.nQqY

PHP, 63 54 bytes
9 bytes saved by @user63956
function a($a){return$a&&!strpos(print_r($a,1)," 0");}

takes an array as input; returns true or false: If $a is not empty,
check if print_r output contains a 0 value.
array solution, 83 bytes
function b($a,$r=0){$r|=$a;foreach($a as$v)$r|=is_array($v)?b($v,1):!!$v;return$r;}

recursive function returns 1 or 0.
breakdown
function b($a,$r=0)
{
    $r|=$a;         # if $a is not empty, set $r (no effect in recursion)
    foreach($a as$v)    # loop through elements:
        $r&=is_array($v)    # 2. if test failed, clear $r
            ?b($v,1)        # 1. if array, recurse
            :!!$v;          #    else test element <>0
    return$r;           # return $r
}

You can save a few bytes with strpos(print_r($a,1)," 0") instead of preg_match(...).

@user63956 ... and it also solves the 0-index problem. I wasn´t aware of the second print_r parameter. Great!

Scala, 53 47 44 bytes
A lambda (assign to a variable or value of type String=>Boolean, and call that variable/value).
x=> !(x=="[]"|x.split("\\D+") contains "0")

I collapsed the filtering logic by splitting the input string at any non-digit character, and then checking if the resulting sequence has a 0 anywhere. We do this via string manipulation because Scala (or Java) cannot represent arbitrarily jagged arrays uniformly at the type level.
I do not handle the case of an empty string "" as that is an illegal representation for a jagged list, the legal empty jagged list would be "[]", which has to be special-cased.
The input format is exactly the OP's input format.

I think you can leave off the parameter type: https://codegolf.meta.stackexchange.com/questions/11223/untyped-functions-in-static-langauges

@BrianMcCutchon You can't, because it doesn't otherwise work in my REPL.

You don't need it to be a standalone REPL line. Assign it to a variable, with the type specified in the variable declaration.

You can remove the parens around the parameter two save two bytes, and by using operator notation (dropping the dot before contains and the parens around "0") al least two more.

Prolog, 23 bytes
\(0^_).
\(A^B):- \A;\B.

Takes a list with ^/2 as the pair constructor, terminated by anything and nested if necessary. Succeeds if it contains 0 and fails if it doesn't.
Invocation
SWISH it online!
?- \(5^4^3^2^1^end).
false.
?- \(5^4^3^2^1^0^end).
true.
?- \(5^4^(1^0^ -1^end)^2^1^end).
true.

Pyth, 5 bytes
.Aa.n

Test suite
Uses the same approach as hvd's Jelly answer, which is fairly different from the existing Pyth answer.
Explanation:
.Aa.n   | Full program
.Aa.nQQ | with implicit variables
--------+-----------------------------------------------------------------
.A      | print whether all the elements of the following list are truthy:
  a   Q |  append the input to
   .nQ  |  the flattened input

Haskell + free, 8 bytes
In order to represent a ragged list in Haskell we use a free monad of lists.  We use the free library to get these free monads.
all(/=0)

Try it online!
Luckily the library implements an instance of Foldable for the new type so all from the base library works.  We just check that all the elements are not equal to zero.
If the input array were of booleans, the actual truthy type of Haskell this could be and.
This is neat but what if we didn't have this instance?
Haskell + free, 18 bytes
(/=0).iter product

Try it online!
Here we use iter to tear down the array.  We call it with product so that we get the product of the entire thing in the end.  If there were any zeros then the result is 0, so to convert to a boolean we just check if it is equal to zero.

Japt, 6 bytes
ÊmUc e

Try it
I think there's probably a way to not need the explicit U. There might also be a shorter way to handle the empty list case, c e alone is right for all other cases.
ÊmUc e #
 m     # Get the minimum of:
Ê      #  The length of the input
       # and:
  U    #  The input
   c   #  flattened
     e #  all elements are truthy

Raku, 45 bytes
{?$_&&!$_».List.flat».List.flat.grep: *==0}

Try it online!

Nibbles, 6.5 bytes
^0?`=@\$D"0"

Attempt This Online!
Nibbles doesn't support heterogenous arrays, so this takes the input as a string in any reasonable format.

Nekomata +  -e, 2 bytes
NZ

Attempt This Online!
NZ
N   Check that the list is not empty
 Z  Check that it does not contain any zeros


text:
Hello World - but alphabetically
This challenge sounds too simple to not already exist, so let me know if it is a duplicate.
The task
Print Hello, world!
The rules
Your code has to be in "byte order". This means that every character / byte has a higher or equal byte value than the preceding character / byte.
Exceptions to this rule are the whitespace characters, which may occur anywhere.
The usual loopholes are not allowed.
Edit: Using built-in functions / constants resolving to Hello, world! is not allowed.
Edit 2: The output may be a(n anonymous) function returning the string,  an expression resolving to the string, or any other way you think should be allowed.
example
HW is valid: 0x48 (H) <= 0x57 (W)
print is invalid: 0x72 (r) > 0x69 (i)
but PRint is valid: 0x50 (P) <= 0x52 (R) <= 0x69 (i) <= 0x6e (n) <= 0x74 (t)
The scoring
This is code-golf so the score is the number of characters / bytes. The lower the score, the higher the ranking.

There are many languages with 1-byte Hello World built-ins. Some may even print Hello World for an empty program.

Very closely related. (The difference is that that one allows each line to be sorted independently, and that it's primarily scored by the number of lines.)

@Dennis Added an extra rule because of that! Thanks

Still trivial in 23, Headsecks, and Lenguage, but much longer than a couple of bytes.

Default output like ans = Hello, world! is that OK? Otherwise, MATLAB and Octave won't be able to attempt this... disp, printf and eval are all in non-alphabetical order.

@StewieGriffin That is now allowed, yes

If not for the lowercase w, Stuck would have done it in 0 bytes, since the rules disallow builtins, but the empty program isn't using a builtin.

@EriktheOutgolfer How is the empty program not a built-in? It's a builtin constant program that results in Hello, World!...

Is scoring characters or bytes? It's not clear...

@mbomb007 Well, I wouldn't consider a built-in program to be the same thing as a builtin function or constant, unless used as an "eval full program" argument (not just "eval"), which seems to me pretty unlikely.

@EriktheOutgolfer It's a constant. And it's part of the language. AKA a built-in.

WhiteSpace, 146 bytes
Since all whitespace may occur everywhere, this is is just the golfed Hello World program. Since whitespace doesn't show properly here, take the following program and replace all . by spaces, > by tabs and ; by newlines.
...;..>>..>.>.;..>>>>;...>;...>>>;...>..;..>>.>..;..>>..>.>>;..>>>>>>>;...>..;...>;.;...>>>.;..>>...>>;;..;.;.;>.>;...>>.>.>>;>...>;..;.;;;..>;;;;

Note
I didn't golf this, LukStorms did. His answer can be found here.

It's not in byte order.

Indeed, but whitespace didn't have to be in byte order; it could appear everywhere

Oh. Good abuse of the rules then

Exactly. That's also part of the reason this is community wiki.

Headsecks - 124 82 chars
Thanks to @MartinEnder for pointing me to a smaller hello-world!
Headsecks looks to be the right language for the job, because its brainfuck except that it takes each character mod 8.
 +19AISYchpx£¨°»ÁËÐÞàèðøĀĈĐĘĦīİĸŀňŐŘŠŨųŻƀƈƐƘƠƪƲƺǁǏǒǟǣǫǴǸȃȈȐțȤȫȴȼɀɋɓɜɠɫɱɹʃʉʑʞʣʩʴʺ˂ˏ

You can try it by going here: https://repl.it/G2I5/1, then here: https://sange.fi/esoteric/brainfuck/impl/interp/i.html

You need to post an actual Headsecks interpreter that will run this, not a Python program to convert to BF and a BF interpreter. Since the program contains non-ASCII, the interpreter you link to needs to handle non-ASCII Headsecks programs.

@mbomb007 there used to be an interpreter, but it 404s now :( https://esolangs.org/wiki/Headsecks

https://github.com/TieSoul/Multilang/blob/master/headsecks.py

@mbomb007 that one handles unicode codepoints, but not the weird wrapping tricks that the bf helloworld uses. I'll try to look for another one, or just rollback to my earlier, longer, answer.

Maybe someone should create an implementation, then have Dennis put it on TIO. Also, someone should edit Esolangs. I was going to, but idr my login info.

CJam, 784 bytes
"

"
"
"')`er~

Try it online!
Not winning anything with that byte count, but this was still fun to make.
Explanation
The first large string encodes Hello, world! using only whitespace. Each character is mapped to a tab, a space, and a number of linefeeds equal to its codepoint minus 32.
Next, the string is transliterated by replacing tabs with ' and linefeeds with ). This results in many sequences of a literal space character followed by some number of increments. The string is eval'ed with ~, pushing the spaces and incrementing them to proper characters.
The stack is implicitly output at the end of the program.

Excellent, finally a truly clever answer!