text:
Keep the unique characters down
It's very simple: Your program or function should generate the following text:
Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.

Fine print
You may write a program or function, which returns the output as a string or printing it to STDOUT (or closest alternative). You may optionally include a single trailing newline in the output.
Scoring
The number of bytes in your code multiplied by the number of unique bytes in your code
Lowest score wins.
For example, a brainfuck or a whitespace answer would have a huge advantage here, as the multiplier would be very low (8 and 3 respectively). However, generally, writing programs in those languages produces much longer code which may negate that advantage.
Standard loopholes which are no longer funny are banned.

I'm assuming casing has to be exact?

@crayzeedude yes, that's sort of the point

Alright. Just clarifying. :p

With JSfuck the score is near 200K * 6. I'll try something else

I suspect we would see some very creative solutions from the non-golfing languages if the score was changed to reward small unique counts (such as sqrt(bytecount)+uniquecount^2). The golfing languages would still win but some of the techniques I explored in my answer would beat the simple 'print the text' solution.

@CarpetPython There was some debate about this in the sandbox, and ultimately I decided there was no way to TRULY level the playing field. Notice that whitespace and insomnia have the highest scores anyway!

As I wrote somewhere, if we assume that using more bytes to compensate for less unique characters behaves similarly to converting numbers into different bases, then approximately bytecount~Log(X,unique), with X some constant for this problem. Thus unique^bytecount ~ constant. Computing this score (log2) gives python2_mbomb007 728, python2_carpetpython 744, ruby 756, Fish 825, Insomnia 1148, cjam 1277, whitespace 1484, brainfuck 3546. So except for the brainfuck answer, it is relatively constant...

Also, applying zlib::deflate on the string would give a score of Log(95unique ^ 123bytes,2)+1 = 809.

Related: Print a string in as few distinct characters as possible

Insomnia, 575 bytes * 4 = 2300
dyedd=dyyyye=d=yd=dddde=ded=deey=eyy=de=edd=eydyee=yeyy=yey==ddyee=eydee=y=eyeedd=dde=yddd=eede=yedde=eeyd==yeyy=yyddy=eyy=dy=dddye=dyey=ede=yddd=dde=de=yyye=yyye=ddyyy=dyy=yeyddy=eyyyde=eed=ddd=yd=edyyd=eeydd=yedd=eye=eee=eeyy=yyyedde=d=eyyyedy=d=yddyye==dyyede=ddd=eydd=yd=ddde==eeeeyy=yeyd=deyy=yyy=ydy=dy=dd=e=ey=dddddy=yeey=ey=eed=ddd=eedy=ddddde=ydeyy=edd=ydy=ddy=yeedd=ydde=dde=edyye=ded=yeed=dddddde=eedy=eyde=ydy=ydydd=eyydd=dd=dddd=ddyye=ydeey=ed=eeeye=y=ydydde=eyyd=eyee=dy=edeyed=dyed==eyyddey=dd=yddd=yddd=de=ddedy=eyydd=eeedy==eyyydeee=d=d=eydd=yey=dyy==yyyedy=

Uses 4 characters dye=.
Solution 1b (unpublished): 783 bytes * 3 = 2349
eeeeyeeyy=eeyy=yeyye=yyyeeyye=eeeye=yeyey=eyeyyy=eyy=eeyeye=yeyeyyy=yyeeye=yeyy=yey==yyeyeyeye=eyyey=y=yyyyyy=y=eyyeyyyyyyye=eeye=yyeeyye=eyeyeyyy==yeyy=yeyyyeyye=yyyeeyy==eeyyeee==eeyye=yyyyeyyeyyye=yyyyyyy=yeye=eyyyyy=eeye=eeyeeeeey=eyeye=eeee=yeyyye=eyyyyye=y=eeeyyy=eyyeyee=yyy=eyye=yeyeeee=yyeyeyyyy=eeyy=yyyyy=eyyyy=yyeeyye=e=eyyyyy=eyey==eyeyy=yyyyyeyeyeye=ye=yyyyyy==eeeeyy=yeye=yeyyey=yyy=eyyyeeeye==yeeyyeyy=e==yeeeyyyeyy=yeey=ey=eee=eyeyy=yyeeee=yeeyyyyy=yee=yeyyy=yeeeeyy=eyeeeeeye=eeeyy=yyeeeeyyye=yey=yyyyeeyye=yyyyyyy=yeee=eeeeyyeye=eyeeye=eeyyeyyy=eeyee=yyyyyeeyy=eee=eeyyeyyyyy=eeey=eyyeeyy=eyyeyyy=eeeeyeee=eeeye=y=yyyeyy=yyeeee=yyeyey=ey=eyyyyyeyyy=yeye==yeeyyyeyy=yeye=yyyyeeyy=eeeyyeeyyy=yeeyeyyy=eeyye=eee=eyyye==eyeyeyyyyy=e=eeyeeye=yeey=eyeyy=eyeye=ey=eyyeye=

Only uses 3 characters ey=.
Solution 1: 826 bytes * 3 = 2478
yoyoy~oyoyo~oyooyy~ooyyoyy~ooyyyyoy~~yoyyo~ooyoooyooo~yoyyo~oyoyoyyy~yyo~oyyoo~~ooooy~oyyyyy~oyoyoo~~oyyyoooyy~~oyoyooyyy~yyooo~yoyo~yoyyyyo~yooyo~y~yyoyyyooyy~oyyooy~ooyoy~oyyooy~ooyyo~yoyyoo~o~ooyo~yooyyoo~yoyoy~ooyyyyooo~oyoyyo~yyoyyyoo~yyo~yyooyyo~yoyyoooy~~yoyyyooyoyy~oyoyyy~yoooyyoy~yooyy~yooyyo~yyooyyoo~oyoyo~oyyy~oyyo~oyyoyo~oyyyoo~oyoyyoo~yooyo~ooooo~~yoyyoyyoyoo~yoyyooo~y~ooooy~yyyoy~ooooyyoyyoy~oyyoo~oyyoyo~yoyyyooy~oyooo~yoyyoyy~yyyyyo~oyooy~oyoyy~yoyyyoy~ooyoy~yoyyoooy~~oyyyo~ooooooy~yooyoyyoyo~yooyyo~oooyyo~yoyooyyo~oyyy~o~yooooy~oyoyyooooy~~yoyyooyyo~oy~yyyoyyyyy~yoyyyoy~yooo~oooy~oooooyyoyyyo~yoyyo~y~oooyyyoyoo~yyooooyoyy~y~oooyyyoy~~yoy~oyyoyoyyy~yoyyyyy~oyooo~yyyyooo~yooyyoy~yooyo~yoyyyo~yyoyyyo~o~ooooooyoy~oyoyyoy~yyoooo~ooooyy~oyoyoy~ooyyo~yyoooyo~yyyyyo~oyyo~yooyyooyyoy~~ooyyyyoyyy~ooyyo~yyooo~

Only uses 3 characters: yo~. A program is used to generate this.
Currently, all programs only use instructions 0, 1, 2, 6. In other words, they manipulate the bits in a single byte and print out the result.

CJam, 266 281 456 bytes * 14 12 7 unique = 3724 3372 3192
Try it online.
14301201124204202034420112034224204431020210101232301021240204310431312122132100240400222324402030223103420431324402222132223233141443401210314023001122320404112224314302132421403301243334313000011124244441400003310332301330220022110121411122100040310110020040121444302100143202204330334033211334242120304123121024200421121232100303121022431044444423243331440434010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

Explanation
The strategy I've used is to treat each character in the string as a base-123 digit and encode that as a decimal number in the program. The program then converts that number back to base 123 and maps each base-123 digit back to a character. Because it's hard to explain why the program is in its current state, I'll explain each version of it.
Here's what the end of the program looked like in the first version:
...2068438725 123b:c

This implements the strategy in the most straightforward way possible. The number, encoded normally in base 10, is converted back to base 123 and each base-123 digit is mapped back to a character. But this uses 4 unique non-digit characters, and being able to get rid of any one of them would likely be worth the size hit due to having to use less straightforward code.
First, I realized that I could get rid of the b and the : operators by creating them at runtime as their ASCII character values converted back to a character (with the already present c operator) and evaluating them with the ~ operator. It turned out to be a little tricky to do this with the : operator, since it has to be parsed together with the following c operator. I solved this by producing the characters : and c and then producing and evaluating the character +, which concatenates the former two characters into the string :c which can then be evaluated properly.
Second, I realized that the ~ operator I just introduced had a handy new overloaded variant: when given a number, it produces the bitwise complement. By using this twice in a row after a number, I could introduce a token break in the source with no resultant computational effect, allowing me to replace the spaces used to separate numbers with ~~.
The final result is 15 more bytes of code at the end, but this cost is greatly outweighed by the benefit of eliminating 2 unique characters out of 14. Here's a comparison of the end of the first version with the end of the second version:
...2068438725  123[ b  ][   :c    ]
...2068438725~~123~~98c~58c99c43c~~

Using any fewer than the 2 operators I was using would be impossible, but I still wanted fewer unique characters. So the next step was to eliminate digits. By changing the number's encoding so that each decimal digit was really a base-5 digit, I could potentially eliminate the digits 6-9. Before eliminating anything from the end of the prgoram, it looked like this:
...4010014400 10b5b123b:c

As mentioned before, eliminating the space is easy. But the b, :, and c would not be so easy, as their character codes are 98, 58, and 99, respectively. These all contained digits marked for elimination, so I had to find ways to derive them all. And the only useful numeric operators with character values not containing 5-9 were decrement, increment, multiply, and add.
For 98, I initially used 100~~40c~40c~, which decrements 100 twice. But then I realized I could make yet another use of the ~ operator, as bitwise complement lets me get negative numbers which, when added, let me emulate subtraction. So I then used 100~~1~43c~, which adds 100 and -2 and is 2 bytes smaller. For 58, I used 44~~14~~43c~, which adds 44 and 14. And for 99, I used 100~~40c~, which decrements 100.
The final result is pretty big and obfuscated, but the cost of the significantly larger number and processing code were slightly outweighed by the big benefit of eliminating 5 unique characters out of 12. Here's a comparison of the final end of the program before eliminations and after eliminations:
...4010014400  10[      b      ][  5  ][     b     ]123[      b      ][            :c            ]
...4010014400~~10~~100~~1~43c~c~4~~41c~100~~1~43c~c~123~~100~~1~43c~c~44~~14~~43c~c100~~40c~c43c~~

Ok, now I'm impressed. How do base 6 digits, base 7 digits, etc. compare to base 5?

@durron597 They don't really make the computations any easier, as the character codes of the operators I need (98, 58, and 99) are still out of range. And incrementing the base only decreases the total size of the program by 8-10%, which isn't enough to make up for the 10-15% score gained by having a new unique character. Re-including the b operator similarly isn't worth it.

Take a number x, and convert it to base b. Its length will be floor(log_b(x)+1), and it will contain b different symbols. So the score is b*floor(log_b(x)+1). x is a given large number, and if you plot this for b, you'll find the minimum is pretty much at b=3. Ie, the length reduces slightly as you use higher bases (log), but size of the charset increases linearly, so it isn't worth it. Made a simple whitespace program, but it gets only a score of 4134.

@blutorange You should put up the whitespace program. 4134 is enough for second place

Whitespace, 1157 937 bytes * 3 unique = 3471 2811
By popular(?) request, I'm posting my whitespace solution.
In order to reduce the code needed, I hardcoded the entire string as one binary number (7 bits for each byte). A simple loop extracts the characters and prints them.
Source code on filebin.ca.
NOTE: The specifications allow for arbitrary large integers, but the Haskell interpreter on the official page is limited to 20 bits. Use, for example, this ruby interpreter on github/hostilefork/whitespaces.
The ruby script to create the whitespace program (l=WHITESPACE, t=TAB, u=NEWLINE, everything after // ignored, writes to a file prog.h):
str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.'

def b2ws(bin)
    bin.chars.map{|x|x=='0' ? "l" : "t"}.join
end
def d2ws(dec,pad=0)
    b2ws(dec.to_s(2).rjust(pad,'0'))
end

bin = str.reverse.chars.map do |x|
    "  " + d2ws(x.getbyte(0),7) + " // char <#{x=="\n" ? "LF" : x}>"
end
data = "lll // pushes string as one large number\n#{bin.join("\n")}\nu"

File.open('prog.h','w') do |fout|
    fout << data << "\n"
    fout << <<-eos

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu
    eos
end

For illustration, the whitespace program in human-readable form. See below for a simple script to convert it to an actual whitespace program.
lll // pushes string as one large number
  ltltttl // char <.>
  ttltltt // char <k>
  ttltttt // char <o>
  ttltttt // char <o>
  ttlttll // char <l>
  ltlllll // char < >
  ttllllt // char
  ltlllll // char < >
  ttlltlt // char <e>
  ttlttlt // char <m>
  ltlllll // char < >
  ttllttt // char <g>
  ttltttl // char <n>
  ttltllt // char
  tttlttl // char <v>
  ttltllt // char
  ttllttt // char <g>
  ltlllll // char < >
  ltllltl // char <">
  ltlttll // char <,>
  tlllttt // char <G>
  tlltttt // char <O>
  tllltll // char <D>
  ltlllll // char < >
  tlttllt // char <Y>
  tlttltl // char <Z>
  tlllllt // char
  tllttll // char <L>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltlllll // char < >
  tltlltl // char <R>
  tllltlt // char <E>
  tltlttl // char <V>
  tlltttt // char <O>
  ltlllll // char < >
  tltlltt // char <S>
  tltllll // char

  tllttlt // char <M>
  tltltlt // char
  tlltltl // char <J>
  ltlllll // char < >
  tlttlll // char <X>
  tlltttt // char <O>
  tlllttl // char <F>
  ltlllll // char < >
  tlltttl // char <N>
  tltlttt // char <W>
  tlltttt // char <O>
  tltlltl // char <R>
  tlllltl // char
  ltlllll // char < >
  tlltltt // char <K>
  tlllltt // char <C>
  tlltllt // char
  tltltlt // char
  tltlllt // char <Q>
  ltlllll // char < >
  tllltlt // char <E>
  tlltlll // char <H>
  tltltll // char <T>
  ltllltl // char <">
  ltlllll // char < >
  ltttltl // char <:>
  ltltllt // char <)>
  ttlltlt // char <e>
  ttllltt // char <c>
  ttllllt // char
  ttlltlt // char <e>
  tttllll // char

  ltlllll // char < >
  ttttllt // char <y>
  ttlttlt // char <m>
  ltlllll // char < >
  tttlltl // char <r>
  ttltttt // char <o>
  ttllttl // char <f>
  ltlllll // char < >
  ttttllt // char <y>
  ttlltll // char <d>
  tttlttt // char <w>
  ttltttt // char <o>
  tttlltl // char <r>
  ltlllll // char < >
  ttltttt // char <o>
  ttltttt // char <o>
  tttltll // char <t>
  ltlllll // char < >
  tttltll // char <t>
  tttlltt // char <s>
  tttltlt // char
  ttltltl // char <j>
  ltltlll // char <(>
  ltlllll // char < >
  ttlltll // char <d>
  ttlltlt // char <e>
  tttltll // char <t>
  ttltttt // char <o>
  tttltlt // char
  tttlllt // char <q>
  ltlllll // char < >
  ttttllt // char <y>
  ttlttll // char <l>
  tttlltt // char <s>
  tttltlt // char
  ttltttt // char <o>
  ttltllt // char
  ttttlll // char <x>
  ttltttt // char <o>
  ttltttl // char <n>
  ttllltl // char
  ttltttt // char <o>
  ltlllll // char < >
  ttltlll // char <h>
  tttltll // char <t>
  ttlltlt // char <e>
  ttllltl // char
  ttllllt // char
  ttttltl // char <z>
  ttltllt // char
  ttlttll // char <l>
  tllltlt // char <E>
u

// output string loop
ulllu // label 0

  // extract, print, and remove the last 7 bits of the data
  lul   // dup
  llltlllllllu // push 128
  tltt // mod
  tull  // print as char
  llltlllllllu // push 128
  tltl // div

  // break loop if EOS
  lul   // dup
  utltu // jump to 1 if top of stack is zero

ululu // jump to 0

ulltu // label 1
uuu

Basically, the string to output is a long integer, and you need to reduce its score.

Take a number x, and convert it to base b. Its length will be floor(log_b(x)+1), and it will contain b different symbols. So the score is b*floor(log_b(x)+1). x is a given large number, and if you plot this for b, you'll find the minimum is pretty much at b=3 (and b=2 is almost as good). Ie, the length reduces slightly as you use higher bases (log), but size of the charset increases linearly, so it isn't worth it.

Thus I looked for a language with only 0/1's, but I didn't find any, and then I remembered there was whitespace and tried it. In whitespace, you can enter binary numbers with 0's and 1's directly.

Old code, worse score but more interesting
Old code on filebin.
The ruby script I used for creating the program (l=WHITESPACE, t=TAB, u=NEWLINE, everything after // ignored, writes to a file prog.h):
str = 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.' + "\n"

def shift(x)
    (x-97)%128
end

EOS = "lttltl" #26
STACK = []

bin = str.reverse.chars.map do |x|
    byte = shift(x.getbyte(0))
    rf = STACK.index(byte)
    STACK.unshift(byte)

    y = byte.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
    ph = "lll#{y}u" # pushing directly
    if rf
        bn = rf.to_s(2).chars.map{|y|y=='0' ? 'l' : 't'}.join
        cp = "ltll#{bn}u" # copying from stack
    end

    if STACK.size>0 && STACK[0]==STACK[1]
        "lul // dup #{x.inspect}"
    elsif cp && cp.size < ph.size
        "#{cp} // copy <#{x.inspect}> (from #{rf})"
    else
        "#{ph} // push <#{x.inspect}> (#{shift(x.getbyte(0))})"
    end
end

File.open('prog.h','w') do |fout|
    fout << "ll#{EOS}u // push EOS" << "\n"
    fout << bin.join("\n") << "\n"
    fout << <<-eos
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  ll#{EOS}u // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu
    eos
end

For illustration, the whitespace program in human-readable form. See below for a simple script to convert it to an actual whitespace program.
lllttltlu // push EOS
llltltlltu // push <"\n"> (41)
llltllttltu // push <"."> (77)
llltltlu // push <"k"> (10)
llltttlu // push <"o"> (14)
lul // dup "o"
llltlttu // push <"l"> (11)
lllttttttu // push <" "> (63)
llllu // push <"a"> (0)
ltlltu // copy <" "> (from 1)
llltllu // push <"e"> (4)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
lllttlu // push <"g"> (6)
lllttltu // push <"n"> (13)
llltlllu // push <"i"> (8)
llltltltu // push <"v"> (21)
ltlltu // copy <"i"> (from 1)
lllttlu // push <"g"> (6)
ltllttlu // copy <" "> (from 6)
llltllllltu // push <"\""> (65)
llltlltlttu // push <","> (75)
lllttllttlu // push <"G"> (102)
lllttltttlu // push <"O"> (110)
lllttlllttu // push <"D"> (99)
ltlltltu // copy <" "> (from 5)
lllttttlllu // push <"Y"> (120)
lllttttlltu // push <"Z"> (121)
lllttlllllu // push <"A"> (96)
lllttltlttu // push <"L"> (107)
ltlltllu // copy <" "> (from 4)
lllttlltllu // push <"E"> (100)
lllttlltttu // push <"H"> (103)
llltttllttu // push <"T"> (115)
ltllttu // copy <" "> (from 3)
llltttllltu // push <"R"> (113)
ltlltllu // copy <"E"> (from 4)
llltttltltu // push <"V"> (117)
ltlltttlu // copy <"O"> (from 14)
ltlltllu // copy <" "> (from 4)
llltttlltlu // push <"S"> (114)
lllttlttttu // push <"P"> (111)
lllttlttllu // push <"M"> (108)
llltttltllu // push <"U"> (116)
lllttltlltu // push <"J"> (105)
ltlltltu // copy <" "> (from 5)
llltttltttu // push <"X"> (119)
ltlltlllu // copy <"O"> (from 8)
lllttlltltu // push <"F"> (101)
ltllttu // copy <" "> (from 3)
lllttlttltu // push <"N"> (109)
llltttlttlu // push <"W"> (118)
ltlltllu // copy <"O"> (from 4)
ltlltllltu // copy <"R"> (from 17)
lllttlllltu // push <"B"> (97)
ltlltltu // copy <" "> (from 5)
lllttltltlu // push <"K"> (106)
lllttllltlu // push <"C"> (98)
lllttltlllu // push <"I"> (104)
ltllttttu // copy <"U"> (from 15)
llltttllllu // push <"Q"> (112)
ltlltltu // copy <" "> (from 5)
ltllttlltu // copy <"E"> (from 25)
ltllttttlu // copy <"H"> (from 30)
ltllttttlu // copy <"T"> (from 30)
llltllllltu // push <"\""> (65)
ltlltllu // copy <" "> (from 4)
llltlttlltu // push <":"> (89)
llltlltlllu // push <")"> (72)
llltllu // push <"e"> (4)
llltlu // push <"c"> (2)
llllu // push <"a"> (0)
llltllu // push <"e"> (4)
lllttttu // push <"p"> (15)
ltlltttu // copy <" "> (from 7)
lllttlllu // push <"y"> (24)
lllttllu // push <"m"> (12)
ltlltlu // copy <" "> (from 2)
llltllltu // push <"r"> (17)
llltttlu // push <"o"> (14)
llltltu // push <"f"> (5)
ltllttu // copy <" "> (from 3)
ltllttlu // copy <"y"> (from 6)
lllttu // push <"d"> (3)
llltlttlu // push <"w"> (22)
llltttlu // push <"o"> (14)
ltlltttu // copy <"r"> (from 7)
ltlltltu // copy <" "> (from 5)
ltlltlu // copy <"o"> (from 2)
lul // dup "o"
llltllttu // push <"t"> (19)
ltllttu // copy <" "> (from 3)
ltlltu // copy <"t"> (from 1)
llltlltlu // push <"s"> (18)
llltltllu // push <"u"> (20)
llltlltu // push <"j"> (9)
llltllltttu // push <"("> (71)
ltlltltu // copy <" "> (from 5)
lllttu // push <"d"> (3)
llltllu // push <"e"> (4)
ltlltttu // copy <"t"> (from 7)
llltttlu // push <"o"> (14)
ltlltttu // copy <"u"> (from 7)
llltllllu // push <"q"> (16)
ltllttlu // copy <" "> (from 6)
lllttlllu // push <"y"> (24)
llltlttu // push <"l"> (11)
llltlltlu // push <"s"> (18)
ltlltltu // copy <"u"> (from 5)
llltttlu // push <"o"> (14)
llltlllu // push <"i"> (8)
llltltttu // push <"x"> (23)
ltlltlu // copy <"o"> (from 2)
lllttltu // push <"n"> (13)
llltu // push <"b"> (1)
ltlltlu // copy <"o"> (from 2)
ltlltlttu // copy <" "> (from 11)
llltttu // push <"h"> (7)
llltllttu // push <"t"> (19)
llltllu // push <"e"> (4)
llltu // push <"b"> (1)
llllu // push <"a"> (0)
lllttlltu // push <"z"> (25)
llltlllu // push <"i"> (8)
llltlttu // push <"l"> (11)
lllttlltllu // push <"E"> (100)
// output string
ullu // label 0
  // add 97 (128) before printing
  lllttlllltu // push 97
  tlll // add
  llltlllllllu // push 128
  tltt // mod
  tull  // print top of stack

  // break loop if EOS
  lul   // dup
  lllttltlu // push EOS
  tllt // subtract
  utltu // jump to 1 if top of stack is zero
uluu // jump to 0

ulltu // label 1
uuu

This whitespace program itself is rather simple, but there are three golfing optimizations:

use lul to clone the stack when there's a duplicate character
use ltl to clone the n-th entry of the stack if its shorter than pushing the char directly
shift down all bytes by 97 (mod 128), makes the binary numbers smaller

A simple ruby script to convert my human readable whitespace code to an actual whitespace program (read a file prog.h and writes to a file prog.ws):
WHITESPACE = "l"
NEWLINE = "u"
TAB = "t"

File.open('prog.ws','w') do |fout|
    code = ""
    fin = File.read('prog.h')
    fin.each_line do |line|
        line.gsub!(/\/\/.*/,'')
        line.scan(/#{NEWLINE}|#{WHITESPACE}|#{TAB}/i) do |x|

            code << case x.downcase
            when NEWLINE.downcase
                "\n"
            when WHITESPACE.downcase
                " "
            when TAB.downcase
                "\t"
            else
                ""
            end
        end
    end
    fout << code
end

The trailing newline is optional, you can save a few characters by not printing it.

Thanks, changed it. Originally, I included it because the Haskell interpreter adddd some debug output, but with the ruby one, it looks clean.

Ruby 144 Bytes * 39 Unique = 5616
puts"Elizabeth obnoxiously quoted (just too rowdy for my peace): \"#{'the quick brown fox jumps over the lazy dog,'.upcase}\" giving me a look."

Sometimes the simplest is the best.

You don't use any simplifications in the data. The cjam and whitespace examples got impressive scores along with some explanations. Even with the bonus for using tidy code in a sane language, it's too much ground to make up!!! Maybe you can re-enter in the length + unique scoring contest.

Brainfuck, 1264 bytes * 7 unique = 8848
Yeah, it's a terrible score.
++++[++++>---<]>++.-[--->+<]>.---.-[--->+<]>++.[->+++++<]>-.+.+++.[--->+<]>---.------------.--[--->+<]>--.+++++[->+++<]>.-------------.++++++++++++.+.+++++++++.[->+++<]>+.++++++.++++++.--.-------.-[--->+<]>.-[---->+<]>++.----[->++++<]>+.++++.------.+++++.+++[->+++<]>.-.-[--->+<]>-.++++++++.-----[->+++<]>+.+++++++++++.--.+.[---->+<]>+++.---[->++++<]>.-----..[--->+<]>-----.---[----->++<]>.---.++++++++.[->+++<]>-.+[--->+<]>++.-[---->+<]>++.++[->+++<]>.+++++++++.+++.[-->+++++<]>+++.+[----->+<]>.--[--->+<]>.-[---->+<]>++.[-->+++++++<]>.-----------.----.++.++.--[->+++<]>.-[-->+++<]>--.[-->+<]>+++.++.>-[--->+<]>-.------------.---.-[-->+<]>--.[-->+++++<]>+.++++.------------.------.++++++++.---[->++++<]>.+[->++<]>.>-[--->+<]>---.---.++++++++.---------.++[----->++<]>.+++[->++<]>.+++++++++.+++++++++.[--->++++<]>.+++++[->++<]>.>-[--->+<]>.--------.+++.+++.+[--->+<]>++++.[-->+++++<]>-.+++++++.--[----->+<]>+.+++++++++++++.--[----->++<]>.>-[--->+<]>-.------------.---.-[-->+<]>--.++++++[->++<]>.-----------.-----[-->+++<]>.-.+[--->+<]>++.++[->++<]>.+++++++++++.--------.--[--->++<]>--.----------.--.++[->+++<]>+.++.[->++++++<]>.[------>+<]>.+++++.-------.-[--->+<]>--.+[----->+<]>.--------.--[--->+<]>-.[->+++<]>+.-[->+++<]>.++[--->++<]>.+++..----.[->++++++++++<]>.

I found that it's possible to use fewer unique characters, but the length would be 10795, times 5 = 53975.

you could do it with only +. not sure it would be any smaller though.

Using only + and . I get 15018 * 2 = 30,036.

><> (Fish) - 578 bytes * 8 unique = 4624
14121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p

My score isn't as competitive as I was hoping, but I thought this solution was still interesting enough to post.
Explanation
The first section of code is a long string of the digits 0-4 that represent a 3 digit base 5 representation for each character in the string. The remaining code takes advantage of the p operator in Fish that allows you to edit the program's source code while the program is running. By using that operator, I was able to generate the Fish code necessary to convert the base 5 characters back to base 10 and output them, and then put that code back into the source code at the beginning of the file before the interpreter reached the end of the line and wrapped around. When the interpreter reaches the end of the line, the code has been modified to look like this:
v4121412412431421124321110441421130402401433401430421141143114240333221142303303210321143224241321121343212340321131301320302344221132340304221130322340321313221100323234202311321143224241341121131213110444324310422421114441421142412420421114400443412442421112412413421113403423411403121100410413412423432421114431403423412401404412402434312421140413410434324324401431443243*3*3+3*1+00p44*4+3*2+01p44*3*4+1+11p44*3*4+1+21p43+3*2*31p43+3*2*41p43*3*41+1p44*3*4+1+42+1p43+3*2*43+1p43+3*2*1+44+1p43+3*2*1+33*1p43*3*3*3+33*1+1p43*3*3*33*2+1p43+3*3*43*1p44*2*1+43*1+1p44*3+3*2+43*2+1p
>55**$5*++ol?!;

When the code wraps around and hits the v operator it goes down to the second line, hits the > operator and proceeds to loop, each time converting the base 5 encoding back to a base 10 ascii value and then outputting that value. When there are no more values on the stack the ? operator will skip to the ; and the program will end.

7, 273 bytes × 7 unique bytes = 1911, noncompeting (language postdates challenge)
501513010250341012432044041204045104011053033043511402401130443235151151105240424404004144031133304214014044433043401032201433022042551243201043511102223044114403120042140450415114434050440500114042432010430032533041340424320250451514210501020420444010403043040402343447403

Try it online!
Unfortunately, this is an old challenge, meaning that I don't get to win with one of my newest languages. However, the language was created with no knowledge of the challenge (I just randomly stumbled across it in "related questions"), but nonetheless pretty much turned out to be a perfect fit.
7 programs on PPCG normally get submitted in packed format, packing eight commands into three bytes (the language has twelve commands, but only eight can appear in a source file, meaning that three bits are enough). However, the language also supports an octal format in which each command is written as an ASCII digit, and that's what I've used here, meaning that only seven distinct bytes are used (the 6 command isn't necessary in a program that just prints a simple string).
The program is very simple; it consists of two stack elements, a long string that just gets printed verbatim, a 7 to separate the elements (unfortunately unavoidable), and 403 which is a simple way of printing a constant string in 7 (40 escapes the second stack element, whilst moving it to the top of the stack, then 3 prints it and discards the old first stack element, i.e. the 403 itself).
So how did I get the string as short as 269 bytes? 7 supports multiple I/O formats, and one of its formats is US-TTY, a character set (specifically, a variant of Baudot) which was widely used before ASCII was invented. (The 5 at the start of the second stack element, i.e. the start of the program, specifies the string's encoding; the rest is the string content itself.) It's a five-bit character set, and the commands 0 to 5 can safely be stored in strings whilst being unescaped consistently (so that escaping it once will exactly reproduce the original), so the language uses pairs of commands (36 options) to encode characters of US-TTY (32 options, with 4 being used for directives to the 7 interpreter itself). Of course, there are more than 32 unique characters that people might want to output (and more than 32 characters appear in the string), so two of the characters are "shift codes" that switch between four character sets (uppercase letters, lowercase letters, figures, and a user-defined "figures extension" which 7 uses for the remaining ASCII characters that aren't in the other character sets; however, all the characters in the string are "natively" in US-TTY so the details of the extension didn't matter). Here's the program's output, with non-ASCII characters added to show where shifts occur (and a line break added to make reading easier, which isn't in the original string):
Ełlizabeth obnoxiously quoted Ø(Łłjust too rowdy for my peaceØ):
"ŁTHE QUICK BROWN FOX JUMPS OVER THE LAZY DOGØ," Łłgiving me a lookØ.

I count ten shifts added to 124 characters of input, a fairly negligible ratio. As such, the ability to use only just over two bytes of input per input character, times 7 unique bytes, means that the score on this challenge is incredibly good. (I guess a language that was designed specifically for this challenge would use some sort of string compression, rather than a pre-existing character set, but even though Baudot and US-TTY weren't designed for golfing, they're still fairly concise.)

That loophole is to prevent writing a language for the purpose of answering a challenge, which this is clearly not. Still worthy of an upvote from me, though I can't accept it despite having the lowest score to date.

Python 2, 163 147 145 143 bytes * 35 36 35 unique = 5705 5292 5220 5005
That's probably about as good as I'm going to get it.
Edits:

Removed .capitalize() in favor of using E.
Changed to use ' instead of backslash escaping quotes.
Removed + and some spaces to use commas in the print statement.

print"Elizabeth obnoxiously quoted (just too rowdy for my peace):",'"the quick brown fox jumps over the lazy dog,"'.upper(),"giving me a look."

I tried looking into starting with binary or hex and converting to the string, but the benefits are lost in the conversion process.

Python 2, 14508 11700 11088 10164 9486 9746 7860 145 bytes * 36 unique = 5220
I saw the title and thought this was an interesting challenge for the rather wordy Python. These are my notes as I tackled this problem.
My first try reduced the uniques to 31:
print''.join(chr([69,108,105,122,97,98,101,116,104,32,111,98,110,111,120,105,111,117,115,108,121,32,113,117,111,116,101,100,32,40,106,117,115,116,32,116,111,111,32,114,111,119,100,121,32,102,111,114,32,109,121,32,112,101,97,99,101,41,58,32,34,84,72,69,32,81,85,73,67,75,32,66,82,79,87,78,32,70,79,88,32,74,85,77,80,83,32,79,86,69,82,32,84,72,69,32,76,65,90,89,32,68,79,71,44,34,32,103,105,118,105,110,103,32,109,101,32,97,32,108,111,111,107,46][r])for r in range(124))

I thought I could do better. By using map, uniques came down to 26:
print''.join(map(chr,(69,108,105,122,97,98,101,116,104,32,111,98,110,111,120,105,111,117,115,108,121,32,113,117,111,116,101,100,32,40,106,117,115,116,32,116,111,111,32,114,111,119,100,121,32,102,111,114,32,109,121,32,112,101,97,99,101,41,58,32,34,84,72,69,32,81,85,73,67,75,32,66,82,79,87,78,32,70,79,88,32,74,85,77,80,83,32,79,86,69,82,32,84,72,69,32,76,65,90,89,32,68,79,71,44,34,32,103,105,118,105,110,103,32,109,101,32,97,32,108,111,111,107,46)))

At about this time, I noticed in the question text that the score was uniques * bytes, not just uniques! That meant my scores for the above were 14508 and 11700. Not very competitive. So I now reduce the bytes by storing the text as a hex string:
# 308*36 = 11088
print''.join(chr(int('456c697a6162657468206f626e6f78696f75736c792071756f74656420286a75737420746f6f20726f77647920666f72206d79207065616365293a202254484520515549434b2042524f574e20464f58204a554d5053204f56455220544845204c415a5920444f472c2220676976696e67206d652061206c6f6f6b2e'[i*2:i*2+2],16)) for i in range(124))

Size was reduced but more unique characters. But if I used a packed 2 digit decimal string with a 32 offset:
# 308*33 = 10164
print''.join(chr(int('37767390656669847200796678798873798583768900818579846968000874858384008479790082798768890070798200778900806965676909260002524037004953413543003450475546003847560042534548510047543750005240370044335857003647391202007173867378710077690065007679797514'[i*2:i*2+2])+32) for i in range(124))

This has the same number of bytes but saves 3 uniques.
I hatch a new plan. If I pack a Python long integer with 7 bit characters, I could extract each one by shifting:
# 306*31 = 9486
h=1073974643401006528619595312441225198653732186368270382545648881135648217524502741093886285232362673460172159947573049818819511630304840724474679255867143965214892747087773876949021986013520804726327302180335979259392708372721217579101211940864406962137554744750
w=''
while h:w=chr(h&127)+w;h>>=7
print w

Well that reduced the score to 9486. An interesting experiment, but nowhere near good enough. Now what if I get rid of the function names and rely on string formatting?
# 443 * 22 = 9746
print('%c'*124)%(69,108,105,122,97,98,101,116,104,32,111,98,110,111,120,105,111,117,115,108,121,32,113,117,111,116,101,100,32,40,106,117,115,116,32,116,111,111,32,114,111,119,100,121,32,102,111,114,32,109,121,32,112,101,97,99,101,41,58,32,34,84,72,69,32,81,85,73,67,75,32,66,82,79,87,78,32,70,79,88,32,74,85,77,80,83,32,79,86,69,82,32,84,72,69,32,76,65,90,89,32,68,79,71,44,34,32,103,105,118,105,110,103,32,109,101,32,97,32,108,111,111,107,46)

I now have only 22 uniques, but the score does not improve.
Ok, What if I took the obvious way and just printed the string:
# 131*60 = 7860
print'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.'

Score of 7860. I should have done this first. But I would not have learned so much.
I guess I could reduce uniques by 26 if I dynamically produced the upper case parts, so:
# 145*36 = 5220
print'Elizabeth obnoxiously quoted (just too rowdy for my peace): '+'"the quick brown fox jumps over the lazy dog,"'.upper()+' giving me a look.'

I think Python will not get much better than 5220. The task of minimising the unique characters in Python sure was instructive though.
Update: mbomb007 has a better Python solution scoring 5005. Nice work.

Nice optimisations in your solution +1. I have edited the title as you have suggested.

><> (Fish) - 138 Bytes * 65 Unique = 8970
The simple route, i.e. Hello World:
!v'Elizabeth obnoxiously quoted (just too rowdy for my peace): "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG," giving me a look.'r!
 >l?!;o

Well, for my first foray into ><> this was a challenge. I think I see some improvements, but it was fun learning it :)
Or to make it overly complicated - 1567 bytes * 27 Unique = 42309
!\f8+3*:o2*f2*-:o3-:of+2+:ofa+-:o1+:o3+:of+:oc-:o\7+:od-:oc+:o1+:o9+: of-:o6+:o6+:o2-:o7-: od+:o\8-:o4+:o6-:o5+:of -:o1-:o\\6+:ob+ :o2-:o1+:o\:o5-:o:o\3+ :o3-:o8+:of4+-:oab ++:o\f4+-:o9+ :o3+: o\!
!5:of+a+:o1-:off+2+o:f-6-oa-:o8-:of3*1-:oa-:o2-:!fo3*7+:o2+:o:d+o:o5!f+:o7-:off+2+o6+:o8-!f:off!f+2+o4-:off+2+ob+!f:o3+::\ff    f f          f        f  f                  f    f        f     \!f-
 -                                               f                   f                    f     f                 f       ff    3 f          f        f  f                  f    f        f       f
 :                                               +                   +                    +     +                 +       ++    * +          +        +  +                  +    +        +       +
 o                                               2                   2                    2     2                 2       2a    1 2          2        2  2                  2    2        2       2
 c                                               +                   +                    +     +                 +       ++    + +          +        +  +                  +    +        +       +
 +                                               o                   o                    o     o                 o      \oo4-o \ o;         o        o  o                  o    o        o       o
 \:off+2+o9-:ob-:o4-:o2+:o2+:of4*%:of2++:o2,3+:o2 +:o3*f-3-:oc-:o3-:o\c+:o4+:oc-:o6-:o8+:o\9-:of 1++:o3-:o8+:o9-:o\8-:o9+:  o9+: o\e-:ob+:o8- :o3+:o3+ :o\4-:o7+:o2-f-:od+:o\2+:o c-:o3-:o\7+:ob\

If you write the string backwards you can drop the r stack reversing :) Also you can move the final o to the blank space at the start of the second line.

@Sp3000 Thanks for the tips!

Any way you could avoid having f f + 2 + o so many times in the complicated one?

In the best one, is there an easy way to upper case? Loop through a subroutine that adds 32 to each in that part of the string, saving you some unique chars, maybe?

@mbomb007 I could optimize that out using the register, or I could even read a space from the source code itself. I'm super new to Fish, so I don't know if that's possible

You can indeed read from the source code. Look up the commands p and g. I just had a great idea though, push your current position onto the register, jump to the location of the routine using ., do stuff, then pop the register and jump back. Not sure how many bytes it'd save...

" "o and 48*o are both shorter than ff+2+o. Also, 33go or something reading a space from the source code.

05AB1E, 380 bytes * 11 chars = 4180 score
"234413410442342343401431404112421343420421440410421432430413441112423432421431401400112130411432430431112431421421112424421434400441112402421424112414441112422401342344401131213112114314242234112311320243232300112231312304322303112240304323112244320302310313112304321234312112314242234112301230330324112233304241134114112403410433410420403112414401112342112413421421412141"3ô5öçJ

Try it online!
Pushes base 5 representation of ASCII chars joined together.
Splits in pieces of 3, converts back to decimal.
Converts ASCII integer back to character.
Joins back together.

Java 8, 141 bytes * 64 unique characters = 9,024
()->{return"Elizabeth obnoxiously quoted (just too rowdy for my peace): \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG,\" giving me a look.";}

141 bytes, 64 unique characters. Approaches other than the simple "return the string" increase the byte count without saving much on characters used.

Perl 6, 139 bytes * 36 unique = 5004
say 'Elizabeth obnoxiously quoted (just too rowdy for my peace): "'~"the quick brown fox jumps over the lazy dog".uc~'," giving me a look.'

Tcl, 345 bytes, 345 x 13 = 4485
\160\165\164\163 [\163\165\142\163\164 [\162\145\147\163\165\142 \55\141\154\154 \50\\\144\\\144\51 "055451724142456450 5742565770515765635471 616557644544 \5052656364 645757 6257674471 465762 5571 6045414345\51\72 \"241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\"\54 475166515647 5545 41 54575753" \\\\1\\1]]\56

Try it online!

Tcl, 337 bytes, 337 x 15 = 5055
\160\165\164\163 [\163\165\142\163\164 [\162\145\147\163\165\142 \55\141\154\154 (\\\144\\\144) "055451724142456450 5742565770515765635471 616557644544 (52656364 645757 6257674471 465762 5571 6045414345)\72 \"241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\"\54 475166515647 5545 41 54575753" \\\\1\\1]]\56

Try it online!

Tcl, 329 bytes, 329 x 16 = 5264
\160\165\164\163 [\163\165\142\163\164 [\162\145\147\163\165\142 \55\141\154\154 (\\d\\d) "055451724142456450 5742565770515765635471 6165576445d (52656364 645757 625767d71 465762 5571 6045414345)\72 \"241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\"\54 475166515647 5545 41 54575753" \\\\1\\1]]\56

Try it online!

Tcl, 333 bytes, 333 x 16 = 5328
\160\165\164\163 [\163\165\142\163\164 [\162\145\147\163\165\142 \55\141\154\154 (\\d\\d) "055451724142456450 5742565770515765635471 6165576445d \5052656364 645757 625767d71 465762 5571 6045414345\51\72 \"241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\"\54 475166515647 5545 41 54575753" \\\\1\\1]]\56

Try it online!

Tcl, 148 bytes, 148 x 37 = 5476
puts "Elizabeth obnoxiously quoted (just too rowdy for my peace): \"[string tou "the quick brown fox jumps over the lazy dog"],\" giving me a look."

Try it online!

Tcl, 277 bytes, 277 x 21 = 5817
\160u\164s [subs\164 [\162\145\147sub \55\141\154\154 (\\d\\d) "0554517241b456450 ob56o7051ous5471 61uo6445d(52us64 64oo 62o67d71 46o62 5571 6045414345): 241005 2125110313 0222172716 061730 1225152023 17260522 241005 14013231 041707\" 475166515647 5545 41 54oo53" \\\\1\\1]]\56

Try it online!

Tcl, 371 bytes, 371 x 16 = 5936
puts "\105\154\151\172\141\142\145t\150 o\142\156o\170\151ous\154\171 \161uot\145\144 \50\152ust too \162o\167\144\171 \146o\162 \155\171 p\145\141\143\145\51\72 \"\124\110\105 \121\125\111\103\113 \102\122\117\127\116 \106\117\130 \112\125\115\120\123 \117\126\105\122 \124\110\105 \114\101\132\131 \104\117\107\54\" \147\151\166\151\156\147 \155\145 \141 \154oo\153\56"

Try it online!

Tcl, 401 bytes, 401 x 16 = 6416
puts "\105\154\151\172\141\142\145\164\150 o\142\156o\170\151o\165\163\154\171 \161\165o\164\145\144 \50\152\165\163\164 \164oo \162o\167\144\171 \146o\162 \155\171 \160\145\141\143\145\51\72 \"\124\110\105 \121\125\111\103\113 \102\122\117\127\116 \106\117\130 \112\125\115\120\123 \117\126\105\122 \124\110\105 \114\101\132\131 \104\117\107\54\" \147\151\166\151\156\147 \155\145 \141 \154oo\153\56"

Try it online!

Tcl, 403 bytes, 403 x 16 = 6448
puts "\105\154\151\172\141\142\145\164\150 o\142\156o\170\151o\165\163\154\171 \161\165o\164\145\144 \50\152\165\163\164 \164oo \162o\167\144\171 \146o\162 \155\171 \160\145\141\143\145\51\72 \42\124\110\105 \121\125\111\103\113 \102\122\117\127\116 \106\117\130 \112\125\115\120\123 \117\126\105\122 \124\110\105 \114\101\132\131 \104\117\107\54\42 \147\151\166\151\156\147 \155\145 \141 \154oo\153\56"

Try it online!

Tcl, 433 bytes, 433 x 15 = 6495
puts "\105\154\151\172\141\142\145\164\150 \157\142\156\157\170\151\157\165\163\154\171 \161\165\157\164\145\144 \50\152\165\163\164 \164\157\157 \162\157\167\144\171 \146\157\162 \155\171 \160\145\141\143\145\51\72 \42\124\110\105 \121\125\111\103\113 \102\122\117\127\116 \106\117\130 \112\125\115\120\123 \117\126\105\122 \124\110\105 \114\101\132\131 \104\117\107\54\42 \147\151\166\151\156\147 \155\145 \141 \154\157\157\153\56"

Try it online!

Tcl, 473 bytes, 473 x 14 = 6622
puts \105\154\151\172\141\142\145\164\150\40\157\142\156\157\170\151\157\165\163\154\171\40\161\165\157\164\145\144\40\50\152\165\163\164\40\164\157\157\40\162\157\167\144\171\40\146\157\162\40\155\171\40\160\145\141\143\145\51\72\40\42\124\110\105\40\121\125\111\103\113\40\102\122\117\127\116\40\106\117\130\40\112\125\115\120\123\40\117\126\105\122\40\124\110\105\40\114\101\132\131\40\104\117\107\54\42\40\147\151\166\151\156\147\40\155\145\40\141\40\154\157\157\153\56

Try it online!

Tcl, 133 bytes, 133 x 60 = 7980
puts "Elizabeth obnoxiously quoted (just too rowdy for my peace): \"THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG,\" giving me a look."

Try it online!

Very failed outgolf

Another fail

Perl 5, 137 bytes * 35 unique = 4795
say'Elizabeth obnoxiously quoted (just too rowdy for my peace): "',uc'the quick brown fox jumps over the lazy dog','," giving me a look.'

Try it online!


text:
Home on the Range of Lists
This challenge is simply to return a list of lists of integers, similar to the Python range function, except that each successive number must be that deep in lists.
Rules:

Create a program or a non-anonymous function
It should return or print the result
The result should be returned in a list (of lists) or array (of arrays)
If the parameter is zero, return an empty list
This should be able to handle an integer parameter 0 <= n < 70.

(recursive solutions blow up pretty fast)

The function should be callable with only the one parameter.
Other behavior is undefined.
This is code golf, so shortest code wins.

Example Call:
rangeList(6)
> [0, [1, [2, [3, [4, [5]]]]]]

Test Cases:
0  => []
1  => [0]
2  => [0, [1]]
6  => [0, [1, [2, [3, [4, [5]]]]]]
26 => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25]]]]]]]]]]]]]]]]]]]]]]]]]]
69 => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25, [26, [27, [28, [29, [30, [31, [32, [33, [34, [35, [36, [37, [38, [39, [40, [41, [42, [43, [44, [45, [46, [47, [48, [49, [50, [51, [52, [53, [54, [55, [56, [57, [58, [59, [60, [61, [62, [63, [64, [65, [66, [67, [68]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

EDIT: isaacg's answer is the shortest so far. I'll update the accepted answer if anyone finds a shorter one in a language that existed at the posting of the challenge. Thanks for playing!

Random comment: It's funny how the character minimum for a title is 15, and I couldn't use "Range of Lists", so I came up with this one on the spot.

That's mostly to prevent people from writing unassigned anonymous functions. Personally, I'd prefer it if it was a function that takes a parameter.

Is it allowed to create two functions, where one is a helper function?

@ProgramFOX Yes. I think code external to your function is fine, since if someone wanted to import math in Python for example, I don't think it could occur inside a function.

@DevonParsons There are plenty of questions that have an example program contained within, but okay.

Are tuples okay?

@WChargin I'm going to say "no." Tuples are immutable, and I'm going to say that mutability is important.

Pyth, 13 bytes
?hu]+HG_UQYQY

Try it here.
                 Implicit:
                 Q = eval(input())
                 Y = []
?           QY   If Q = 0, print Y
 h               else, print the first element of
  u     _UQY     the reduce, where Y is the initial value, over the list
                 reversed(range(Q))
   ]+HG          The reduce function: The list containing H prepended onto G.
                 The new number is inserted into the accumulated list,
                 then the resultant list is wrapped in another list.

APL (13 18)
Assuming ⎕IO=0:
f←{×⍵:⊃,∘⊂∘,/⍳⍵⋄⍬}

Explanation:

×⍵: if ⍵ is positive,

,∘⊂∘,: join the left operand to the enclose of the right operand (i.e. x ,∘⊂∘, y = [x, [y]])
/: reduce
⍳⍵: the numbers 0..⍵-1
⊃: disclose the result

⋄: otherwise

⍬: return the empty list
(this is necessary because / fails on ⍬, and ⍳0 gives the empty list.)

Addendum:
This function returns a nested array. However, it is a bit hard to tell this from APL's default output. It separates array items by spaces, so you can only tell nesting by double spaces. Here is a function that will take a nested array, and return a string, formatting the nested array in Python style (i.e. [a,[b,[c,...]]]).
arrfmt←{0=≡⍵:⍕⍵ ⋄ '[',(1↓∊',',¨∇¨⍵),']'}

I think you need another ∘, after the enclose, otherwise (at least in my interpreter - dyalog14) the last element isn't enclosed. e.g. [0 [1 [2 3]]]

@marinus Can you please verify this?

I changed the problem statement a day or two ago to clarify that defined functions should be assigned to a variable. You should add f← to the start of your program unless you modify it to accept user input.

Also, the output doesn't show how deep in the list a number is vary clearly... is each space an implied bracket?

@MorisZucca I have to agree. See here: http://ngn.github.io/apl/web/#code=%7B%D7%u2375%3A%2C%u2218%u2282/%u2373%u2375%u22C4%u236C%7D%203%0A

@mbomb007 to check how deep the number is in the list, you can try the function in tryapl.org, adding a "]display " in front.

@mbomb007: it encloses properly now, and it is no longer anonymous. APL's default output format for nested lists is indeed not very intuitive, but it returns a nested list nonetheless, which you can check by indexing into the lists. On TryAPL you will get a wrong answer (1..N instead of 0..N-1) because it assumes ⎕IO=1 and doesn't allow you to change it. ngn/apl works.

@marinus I've just tried and ⎕IO←0 works on tryapl.org, so your function works there as well.

@MorisZucca: ah, so they fixed that.

Haskell, 67 bytes
data L=E|I Int|L[L]
1#m=L[I$m-1]
n#m=L[I$m-n,(n-1)#m]
p 0=E
p n=n#n

In Haskell all elements of a list have to be of the same type, so I cannot mix integers with list of integers and I have to define a custom list type L. The helper function # recursively constructs the required list. The main function p checks for the empty list and calls # otherwise.
As new data types cannot be printed by default (the rules allow just to return the list), I add some more code for demonstration purpose:
data L=E|I Int|L[L] deriving Show

Now:
-- mapM_ (print . p) [0..5]
E
L [I 0]
L [I 0,L [I 1]]
L [I 0,L [I 1,L [I 2]]]
L [I 0,L [I 1,L [I 2,L [I 3]]]]
L [I 0,L [I 1,L [I 2,L [I 3,L [I 4]]]]]

Python, 48 bytes
f=lambda n,i=0:i<n and[i]+[f(n,i+1)]*(i<n-1)or[]

Using list multiplication to handle the special case.

I don't think this is Python 2 specific - seems to work in all pythons.

@isaacg Fixed. My original submission wasn't though :)

A tiny char-save:*(i<n-1) can be done as [:n+~i], since it's a singleton list.

Mathematica, 33
f@0={};f@1={0};f@n_:={0,f[n-1]+1}

It looks so simple!

CJam, 16 bytes
Lri){[}%]~;']*~p

This is a full program. It takes input via STDIN and prints the final array on to STDOUT.
As with the other CJam entry, 0 input will print "" as that is the representation of an empty array in CJam.
How it works:
L                   "Put an empty array on stack. This will be used for the 0 input";
 ri)                "Read the input, convert it to integer and increment it";
    {[}%            "Map over the array [0 ... input number] starting another array";
                    "after each element";
        ]~;         "Now on stack, we have input number, an empty array and the final";
                    "opening bracket. Close that array, unwrap it and pop the empty array";
           ']*~     "Put a string containing input number of ] characters and eval it";
                    "This closes all the opened arrays in the map earlier";
               p    "Print the string representation of the array";
                    "If the input was 0, the map runs 1 time and the ; pops that 1 array";
                    "Thus leaving only the initial empty array on stack";

Try it online here

Java, 88 107 105 104 102 bytes
import java.util.*;int o;List f(final int n){return new Stack(){{add(n<1?"":o++);if(o<n)add(f(n));}};}

Pretty long compared to the others, though you can't do much better with Java. A check to determine whether to continue recursion is all it takes.

You need to import java.util.*; for this to be self-containing (or fully qualify java.util.List and java.util.Stack, but that's much longer). +19 to make it 107, still 7 better than the Java answer I was working on :D

I see two you can save: o!=n can be o<n, and you can swap the ternary to o<n?o++:"".

In Java 8, I believe the final on int n can be removed.

JavaScript (ES6) 40
Recursive solution, pretty robust, no blows.
Update Fails near 6500 with 'too much recursion'
F=n=>n--?(R=m=>m<n?[m,R(++m)]:[m])(0):[]

Iterative solution (45)
No limits except memory usage
F=n=>{for(s=n?[--n]:[];n;)s=[--n,s];return s}

Try F(1000): FireBug console will not show you more than 190 nested arrays, but they are there

C# - 100
Simple recursion. Check the zero special case and tick up with one variable, down with the other
object[]A(int y,int x=0){return y==0?new object[0]:y==1?new object[]{x}:new object[]{x,A(--y,++x)};}

C++ 87
(Visual C++ 2012)
int*A(int y,int x=0){int*b=new int{x};return!y?new int:--y?(b[1]=(int)A(y,++x))?b:0:b;}

This one is great, by which I mean byzantine, but it's the same basic idea as the c# one.
It's a C style array implementation, so it doesn't give you an array, it gives a int pointer, in which I was be storing both ints and other pointers. Like this: [0,*] *->[1,#] #-> [2,&] &-> etc, where  the symbols are pseudo code for the int value of a pointer and the --> is where it pointers to in memory.
What an excellent easy to use implementation of c style jagged arrays I've devised (cough), but I maintain it's plausible enough to be within the rules of the question.
There's quite a lot of abusing ternary operators here, and also quite a lot of abusing the implicit cast from int to bool.
Example: If we let int *bar = (int*)A(3);, we can see:
bar
0x003bded8 {0}
((int*)bar[1])[0]
1
((int*)(((int*)bar[1])[1]))[0]
2

Which is pointer talk for [0,[1,[2]]].
Okay, fine. It doesn't actually have to be the awful. Here's some test code for running this c++ code:
int* GetNext(int* p){
  return (int*)p[1];
}

int main()
{
    auto x = 10;
    auto bar = A(x);

    for (int i = 1; i < x; i++){
        bar = GetNext(bar);
        std::cout << bar[0] << std::endl;
    }

}

The C++ version doesn't compile. http://ideone.com/fmcXYP

You should mention the compiler used alongside C++.

@anmolSinghJaggi Yeah, good idea. Visual C++ 2012, which is mostly C++11 compliant.

Old post, but with some tinkering I got it down to 86. Array g(params object[]a)=>a;Array f(int y,int x=0)=>y<1?g():y<2?g(x):g(x,f(y-1,x+1));

Python 2, 56 bytes
I suspect this could be golfed more.
f=lambda n,i=0:[i,f(n,i+1)]if i<n-1 else[i]if n>0 else[]

Tests:
# for n in (0,1,2,6,26,69): print n, '=>', f(n)
0 => []
1 => [0]
2 => [0, [1]]
6 => [0, [1, [2, [3, [4, [5]]]]]]
26 => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25]]]]]]]]]]]]]]]]]]]]]]]]]]
69 => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25, [26, [27, [28, [29, [30, [31, [32, [33, [34, [35, [36, [37, [38, [39, [40, [41, [42, [43, [44, [45, [46, [47, [48, [49, [50, [51, [52, [53, [54, [55, [56, [57, [58, [59, [60, [61, [62, [63, [64, [65, [66, [67, [68]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

Well, you beat my Python solution.

Pyth, 15 bytes
?u[HG)_UtQ]tQQY

Which is really saying, in Python:
Q = eval(input())
if Q:
    print reduce(lambda G,H:[H,G], reverse(range(Q-1)), [Q-1])
else:
    print []

Hey, I'm glad you're learning Pyth! If you want to generate the evaluated input, you can use Q, which does that for you. Also, Y is preinitialized to [].

qJ_1 is the same as !Q. And JtQ actually wastes 1 byte. ?Y!Qu[HG)_UtQ[tQ

Okay I'll take those bytes.

@swstephe If you change [tQ to ]tQ, which is equivalent, you swap to order of operations of ?, so you can replace !Q with Q. This results in ?u[HG)_UtQ]tQQY - 1 more byte saved.

CJam, 17 bytes
I know Optimizer has found 16, but here is the best I can do:
{:I{[}%;{]}I1e>*}

This is a block, the closest thing to a function in CJam, which takes an integer on the stack, and leaves the desired nested array.
Use this program to test it, which puts the input on the stack, then calls the function and inspects the stack. Note that for 0, the stack output will contain "" - this is CJam's native representation of an empty array.

Ruby 46
f=->n{r=a=[]
(0...n).map{|i|a<<a=[i]}
r[0]||r}

Test it online: http://ideone.com/uYRVTa

Haskell, 65 59 45 41 bytes
These nested lists are the same data-structure as rooted Trees, except that they can also be empty. Hence, we can use a list of them - also called a Forest to represent them.
(0!)
data T=N[T]Int
m!n=[N((m+1)!n)m|m<n]

Try it online!
Explanation
First of all we need to implement the Tree data type:
data Tree = Node [Tree] Int

From there it's just recursion using two parameters m (counting up) and n to keep track when to terminate:
m ! n= [ Node ((m+1)!n) m| m<n ]

Alternative, 61 bytes
import Data.Tree
f n=unfoldForest(\b->(b,[b+1|b<n-1]))[0|n>0]

Try it online!
Explanation
The function unfoldForest takes a list of initial values and a function x -> (y,[x]). For each initial value x it unfolds a tree using the function, producing a tuple (y,xs) where y will become the root and the xs are used to repeat the procedure:
unfoldForest (\b -> (b, [b+1 | b < 2]) [0]
  ≡ Node 0 [unfoldForest (\b -> (b, [b+1 | b < 2) [1]]
  ≡ Node 0 [Node 1 [unfoldForest (\b -> (b, [b+1 | b < 2) []]]
  ≡ Node 0 [Node 1 []]

Joe, 8 bytes
Note: This is a non-competing answer. The first version of Joe was released after this question.
F:/+,M]R

What do we have here? F: defines a function F that is a chain of /+,, M] and R. When you call Fn, first Rn gets evaluated, returning range from 0 to n, exclusive. M] wraps each element to a list. Then the list is applied to /+,. x +, y  returns x + [y]. / is a right fold. Thus, /+,a b c d... returns [a, [b, [c, [d...]]].
Example invocations (code is indented by 3, output by 0):
   F:/+,M]R
   F10
[0, [1, [2, [3, [4, [5, [6, [7, [8, [9]]]]]]]]]]
   F2
[0, [1]]
   F1
[0]
   F0
[]
   F_5
[0, [-1, [-2, [-3, [-4]]]]]

Perl - 44
sub t{$r=[($t)=@_];$r=[$t,$r]while--$t>0;$r}

Will add explanation upon request. You can try it here.

I'm wondering, because I'm not familiar with Perl - Does the most deeply nested array have 2 elements in it, one being nil or whatever the equivalent is? I ask because on the page you link to the innermost array looks like (3,)

@DevonParsons the code I added to print it in a readable way adds a comma after each element. undef is the equilvalent of nil or null in Perl and there is not an extra element. Perl flattens arrays so this is creating nested array references.

Ruby - Recursive version - 52
r=->(n,v=nil){(n-=1;n<0 ?v:r[n,(v ?[n,v]:[n])])||[]}

Non-recursive version: 66 62 57
r=->i{(i-1).downto(0).inject(nil){|a,n|a ?[n,a]:[n]}||[]}

Sample output (same for both versions)
p r[0]  # => []
p r[1]  # => [0]
p r[2]  # => [0, [1]]
p r[6]  # => [0, [1, [2, [3, [4, [5]]]]]]
p r[26] # => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25]]]]]]]]]]]]]]]]]]]]]]]]]]
p r[69] # => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25, [26, [27, [28, [29, [30, [31, [32, [33, [34, [35, [36, [37, [38, [39, [40, [41, [42, [43, [44, [45, [46, [47, [48, [49, [50, [51, [52, [53, [54, [55, [56, [57, [58, [59, [60, [61, [62, [63, [64, [65, [66, [67, [68]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

The non-recursive version can handle arbitrarily large input.
p r[1000] # => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25, [26, [27, [28, [29, [30, [31, [32, [33, [34, [35, [36, [37, [38, [39, [40, [41, [42, [43, [44, [45, [46, [47, [48, [49, [50, [51, [52, [53, [54, [55, [56, [57, [58, [59, [60, [61, [62, [63, [64, [65, [66, [67, [68, [69, [70, [71, [72, [73, [74, [75, [76, [77, [78, [79, [80, [81, [82, [83, [84, [85, [86, [87, [88, [89, [90, [91, [92, [93, [94, [95, [96, [97, [98, [99, [100, [101, [102, [103, [104, [105, [106, [107, [108, [109, [110, [111, [112, [113, [114, [115, [116, [117, [118, [119, [120, [121, [122, [123, [124, [125, [126, [127, [128, [129, [130, [131, [132, [133, [134, [135, [136, [137, [138, [139, [140, [141, [142, [143, [144, [145, [146, [147, [148, [149, [150, [151, [152, [153, [154, [155, [156, [157, [158, [159, [160, [161, [162, [163, [164, [165, [166, [167, [168, [169, [170, [171, [172, [173, [174, [175, [176, [177, [178, [179, [180, [181, [182, [183, [184, [185, [186, [187, [188, [189, [190, [191, [192, [193, [194, [195, [196, [197, [198, [199, [200, [201, [202, [203, [204, [205, [206, [207, [208, [209, [210, [211, [212, [213, [214, [215, [216, [217, [218, [219, [220, [221, [222, [223, [224, [225, [226, [227, [228, [229, [230, [231, [232, [233, [234, [235, [236, [237, [238, [239, [240, [241, [242, [243, [244, [245, [246, [247, [248, [249, [250, [251, [252, [253, [254, [255, [256, [257, [258, [259, [260, [261, [262, [263, [264, [265, [266, [267, [268, [269, [270, [271, [272, [273, [274, [275, [276, [277, [278, [279, [280, [281, [282, [283, [284, [285, [286, [287, [288, [289, [290, [291, [292, [293, [294, [295, [296, [297, [298, [299, [300, [301, [302, [303, [304, [305, [306, [307, [308, [309, [310, [311, [312, [313, [314, [315, [316, [317, [318, [319, [320, [321, [322, [323, [324, [325, [326, [327, [328, [329, [330, [331, [332, [333, [334, [335, [336, [337, [338, [339, [340, [341, [342, [343, [344, [345, [346, [347, [348, [349, [350, [351, [352, [353, [354, [355, [356, [357, [358, [359, [360, [361, [362, [363, [364, [365, [366, [367, [368, [369, [370, [371, [372, [373, [374, [375, [376, [377, [378, [379, [380, [381, [382, [383, [384, [385, [386, [387, [388, [389, [390, [391, [392, [393, [394, [395, [396, [397, [398, [399, [400, [401, [402, [403, [404, [405, [406, [407, [408, [409, [410, [411, [412, [413, [414, [415, [416, [417, [418, [419, [420, [421, [422, [423, [424, [425, [426, [427, [428, [429, [430, [431, [432, [433, [434, [435, [436, [437, [438, [439, [440, [441, [442, [443, [444, [445, [446, [447, [448, [449, [450, [451, [452, [453, [454, [455, [456, [457, [458, [459, [460, [461, [462, [463, [464, [465, [466, [467, [468, [469, [470, [471, [472, [473, [474, [475, [476, [477, [478, [479, [480, [481, [482, [483, [484, [485, [486, [487, [488, [489, [490, [491, [492, [493, [494, [495, [496, [497, [498, [499, [500, [501, [502, [503, [504, [505, [506, [507, [508, [509, [510, [511, [512, [513, [514, [515, [516, [517, [518, [519, [520, [521, [522, [523, [524, [525, [526, [527, [528, [529, [530, [531, [532, [533, [534, [535, [536, [537, [538, [539, [540, [541, [542, [543, [544, [545, [546, [547, [548, [549, [550, [551, [552, [553, [554, [555, [556, [557, [558, [559, [560, [561, [562, [563, [564, [565, [566, [567, [568, [569, [570, [571, [572, [573, [574, [575, [576, [577, [578, [579, [580, [581, [582, [583, [584, [585, [586, [587, [588, [589, [590, [591, [592, [593, [594, [595, [596, [597, [598, [599, [600, [601, [602, [603, [604, [605, [606, [607, [608, [609, [610, [611, [612, [613, [614, [615, [616, [617, [618, [619, [620, [621, [622, [623, [624, [625, [626, [627, [628, [629, [630, [631, [632, [633, [634, [635, [636, [637, [638, [639, [640, [641, [642, [643, [644, [645, [646, [647, [648, [649, [650, [651, [652, [653, [654, [655, [656, [657, [658, [659, [660, [661, [662, [663, [664, [665, [666, [667, [668, [669, [670, [671, [672, [673, [674, [675, [676, [677, [678, [679, [680, [681, [682, [683, [684, [685, [686, [687, [688, [689, [690, [691, [692, [693, [694, [695, [696, [697, [698, [699, [700, [701, [702, [703, [704, [705, [706, [707, [708, [709, [710, [711, [712, [713, [714, [715, [716, [717, [718, [719, [720, [721, [722, [723, [724, [725, [726, [727, [728, [729, [730, [731, [732, [733, [734, [735, [736, [737, [738, [739, [740, [741, [742, [743, [744, [745, [746, [747, [748, [749, [750, [751, [752, [753, [754, [755, [756, [757, [758, [759, [760, [761, [762, [763, [764, [765, [766, [767, [768, [769, [770, [771, [772, [773, [774, [775, [776, [777, [778, [779, [780, [781, [782, [783, [784, [785, [786, [787, [788, [789, [790, [791, [792, [793, [794, [795, [796, [797, [798, [799, [800, [801, [802, [803, [804, [805, [806, [807, [808, [809, [810, [811, [812, [813, [814, [815, [816, [817, [818, [819, [820, [821, [822, [823, [824, [825, [826, [827, [828, [829, [830, [831, [832, [833, [834, [835, [836, [837, [838, [839, [840, [841, [842, [843, [844, [845, [846, [847, [848, [849, [850, [851, [852, [853, [854, [855, [856, [857, [858, [859, [860, [861, [862, [863, [864, [865, [866, [867, [868, [869, [870, [871, [872, [873, [874, [875, [876, [877, [878, [879, [880, [881, [882, [883, [884, [885, [886, [887, [888, [889, [890, [891, [892, [893, [894, [895, [896, [897, [898, [899, [900, [901, [902, [903, [904, [905, [906, [907, [908, [909, [910, [911, [912, [913, [914, [915, [916, [917, [918, [919, [920, [921, [922, [923, [924, [925, [926, [927, [928, [929, [930, [931, [932, [933, [934, [935, [936, [937, [938, [939, [940, [941, [942, [943, [944, [945, [946, [947, [948, [949, [950, [951, [952, [953, [954, [955, [956, [957, [958, [959, [960, [961, [962, [963, [964, [965, [966, [967, [968, [969, [970, [971, [972, [973, [974, [975, [976, [977, [978, [979, [980, [981, [982, [983, [984, [985, [986, [987, [988, [989, [990, [991, [992, [993, [994, [995, [996, [997, [998, [999]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

Both versions also gracefully accept negative numbers
p r[-5] # => []

Just curious, at what value does the recursive solution fail (due to memory/stack overflow)?

@mbomb007 On Windows 7 x64, 16Gb RAM, it works on 926 and fails at 927 (stack level too deep (SystemStackError))

JavaScript, 93 bytes
This isn't ideal, but I might as well give it a try. I'll try and golf this further later on, though for now I see no obvious way to.
function f(n){s='[';i=0;while(i<n-1)s+=i+++',[';s+=i||'';do{s+=']'}while(i--);return eval(s)}

You might also try creating a recursive solution, as it might be shorter.

Python, 75 bytes
This is just for show. It's the program I wrote when creating/designing this challenge.
f=lambda x,y=[]:y if x<1 else f(x-1,[x-2]+[y or[x-1]])if x>1 else y or[x-1]

Python, 44
f=lambda n,i=0:i<n-1and[i,f(n,i+1)]or[i][:n]

Recursively creates the tree. The [:n] at the end is to special-case n==0 into giving the empty list.

It was during this challenge that I realized that and and or can have spaces omitted next to integers, but else cannot.

@mbomb007 It's because else starts with e, and things like 1e6 are valid number literals.

I knew that, but I didn't know that was why. Thanks.

@mbomb007 Actually after 2.6 or 2.7 or so you can lose the space before else, e.g. x = 1 if y==2else 5 works.

It doesn't work in Python 2.7.2 http://repl.it/eB6 (But it does work in 3.4)

PHP 5.4 (67 bytes):
I know, I know.
It's far from being the shortest answer.
But it works!
Here it is:
function F($n){for($c=$n?[--$n]:[];~$n&&$n--;$c=[$n,$c]);return$c;}

You can test it right here: https://ideone.com/42L35E (ignore the error)

Javascript (57 bytes):
This is the same exact code except that Javascript is picky about the return and I've reduced the variable names:
function F(n){for(c=n?[--n]:[];~n&&n--;c=[n,c]);return c}

See? Same code!

ES6 (49 bytes):
Basically the same exact code, but reduced for ES6:
F=n=>{for(c=n?[--n]:[];~n&&n--;c=[n,c]);return c}

I specified no anonymous functions, or it was in the comments somewhere. I'll make it clearer.

@mbomb007 It wasn't specified. There was nothing enforcing a name on the function. But I've changed it.

There was a comment by me below the question: "That's mostly to prevent people from writing unassigned anonymous functions. Personally, I'd prefer it if it was a function that takes a parameter."

And I did change the question. But it's pretty standard codegolf for functions that they have to be callable by name (aka, more than once and without typing the entire function again.) That's why you see everyone else's functions using f=lambda...

@mbomb007 But it's pretty standard codegolf for functions that they have to be callable by name (aka, more than once and without typing the entire function again.) --> never heard of this, and I use this website for somewhat close to a year. Besides, this is an invalid argument since you can assign the functions to a variable.

But they must be assigned. That's my point.

@mbomb007 No, they can be assigned, they don't must. Try !function(){alert('it runs')}() and try F=function(){alert('it runs')};F(); on your browser console.

I declare that they must for this question.

Javascript (114 bytes):
Everybody else was doing recursive, so I wanted to try an iterative solution.  I have too many special cases, though.
I hold a master list, and then loop and append new lists with new numbers.
function q(n){a=[];if(n==1)a=[0];else if(n!=0){a=[0,b=[]];for(i=1;i<n;){c=[];b.push(c);b.push(i++);b=c}}return a}

Common Lisp (95 bytes):
(defun f(n &optional(i 0))(cond((< i(1- n))(cons i(list(f n(1+ i)))))((> n 0)(list i))(t nil)))

JavaScript, 35 37 bytes
Recursive solution
f=(n,x=[])=>n?f(--n,x[0]?[n,x]:[n]):x

Try it online!

05AB1E, 11 bytes
_i¯ëFNI<α)R

Try it online or verify all test cases.
11-bytes alternative:
_i¯ëÝ¨Rvy)R

Try it online or verify all test cases.
Explanation:
05AB1E has no loops that go downwards, so to loop in the range (input, 0] I either have to:

Create that range first (Ý¨R; create range [0, input], remove last item, reverse), and then loop over it (vy);
Or loop in the range [0, input) instead (F), and take the absolute difference between the loop-index and the input-1 (NI<α).

_i          # If the (implicit) input is 0:
  ¯         #  Push the global array (empty by default)
 ë          # Else:
  F         #  Loop `N` in the range [0, (implicit) input):
   N        #   Push index `N`
    I<      #   Push input-1
      α     #   Take the absolute difference between the two
       )    #   Wrap everything on the stack into a list
        R   #   Reverse the list
            # (output the result implicitly after the if/loop)

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:
Write a Kolmogorov Complexity Solver
The Kolmogorov complexity of a string S is the length of the shortest program P, written in some programming language L, whose output is exactly S.
(Yes, the real definition is more formal but this will suffice for the challenge.)
Your task in this challenge is to write the shortest possible "Kolmogorov complexity solver", that is, a program written in L itself that takes in a string S and returns the shortest P written in L that outputs S.
The naive approach to this is to iterate over all length 1 programs, then all length 2 programs, then all length 3 programs, and so on, running each of them and measuring the output until a program that outputs S is found. The issue with this approach is that some of these programs may never stop running, which means that the solver itself may never stop. And due to the halting problem there is no surefire way to avoid the programs that don't stop.
A simple, though imperfect solution is to put a time limit on the execution time of each of the potential P's. Programs that don't happen to halt in time may be passed over, but the solver will definitely stop (assuming that a program in L can indeed output S within the time limit).
Challenge
Write your solver as a program or function that takes in three things:

The string S.
A positive integer T that is the time limit in seconds or some smaller time span (e.g. milliseconds).
A string A of the alphabet of characters to use for potential P's.

And outputs the shortest P that only contains characters in A, runs in less than T time units, and outputs S.
This is the general pseudocode:
Function KolmogorovComplexitySolver(S, T, A):
    Assign N to 0
    Loop until function returns:
        In any order, iterate over all strings of length N that only contain characters from *A*. Call the current string P:
            Execute P, saving the output to O, stopping the execution if it takes longer than time T
            If (P did not throw any errors) and (P did not timeout) and (O and S are identical):
                Return P
        Add 1 to N

Details

You may assume that there will always be a P made from the characters in A that runs in time T that outputs S.
You may assume that the execution of the potential P's will not have side effects that prevent the solver from running or working correctly (like messing with the solver's allocated memory).
You may not assume that the potential P's are error free. Be sure to include try/catch blocks or whatever applicable around the execution call.
If there are multiple shortest P's, then any will suffice. "Shortness" is measured in characters not bytes.
The output of potential P's is what's printed to stdout (or your language's usual output area). The empty string is a potential P.
Ideally your solver will allow A to contain any characters. A must at least to be able to contain printable ASCII characters plus tabs and newlines.
Input may come from file/stdin/command line/function args. Output goes to stdout or similar, or can be returned as a string if you wrote a function.

Scoring
The submission with the fewest bytes wins. Tiebreaker goes to earliest posted submission.

My brain hurts.

Can you relax the requirement that the target language and language which the meta solver is written in must be the same?

And wouldn't it be possible to just write a program which converts the output into string literal representation of the language?

@n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳  No, the point is to do it in the same language. Yes, but that would not always be the shortest program.

@Calvin'sHobbies: So in the end, it is only a code golf challenge to find out which language can easily write code to call facilities (or implement compiler where absent) to compile the language itself?

Python 3, 240 236 bytes
import subprocess as s,itertools as i
def f(S,T,A,N=0):
 while 1:
  for P in i.product(A,repeat=N):
   try:
    P="".join(P);open("a","w").write(P)
    if s.check_output(["py","-3","a"],timeout=T).decode()==S:return P
   except:1
  N+=1

Don't run this. On my computer, at least, I found the program really hard to stop once it started running due to the pop-up windows created per process.
timeouts were only added to subprocess.check_output in Python 3, which is why we're using this rather than Python 2.
Here's an alternative version with a time.sleep that also prints all valid programs found along the way, as well as their corresponding output:
import subprocess as s,itertools as i
import time
def f(S,T,A,N=0):
 while 1:
  for P in i.product(A,repeat=N):
   time.sleep(0.2)
   try:
    P="".join(P);open("a","w").write(P);C=s.check_output(["py","-3","a"],timeout=T).decode()
    print(P,repr(C))
    if C==S:return P
   except:1
  N+=1

The program uses the filename a for each program P to be tested, so if you run this make sure you don't already have a file of that name. Replace ["py","-3","a"] with the appropriate command for your setup (e.g. ["python","a"] or ["python3","a"]).
Feel free to change the sleep duration at your own risk :). Call like f("1\r\n",1,"1()print"), where T is timeout in seconds.
First few lines of output from the tester with the above call:
 ''
1 ''
11 ''
() ''
111 ''
(1) ''
int ''
1111 ''

(If you want to help the program along a bit  you can change P="".join(P) to P="print"+"".join(P))
Since the above programs all have no output, here's the result for f("1\r\n",1,["print","(",")","1"]) (tokens aren't part of the challenge, but I wanted to show what happens):
 ''
print ''
1 ''
() ''
11 ''
print() '\r\n'
(print) ''
(1) ''
111 ''
print(print) '<built-in function print>\r\n'
print(1) '1\r\n'

The return value is the string 'print(1)'.
Finally, just for fun, here's what happens if the alphabet is string.printable, i.e.
0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c

Pastebin link of all valid 0-2 char Python 3 programs

authors: n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

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


text:
Bookkeeping for the Sex Bob-ombs (check if a running sum ever gets too low)
Believe it or not, the Sex Bob-ombs have become a world famous band and are currently on world tour! As their bookkeeper you must oversee their day to day finances and provide regular reports.
Every few weeks you compile a list of their expenses (in whole USD) in the order they were incurred.
For example, the list
378
-95
2234

means that $378 was deposited to their account, and after that $95 was withdrawn, and after that $2234 was deposited.
You want to make sure that the running sum of these values never goes below some threshold value T. You decide to write a program to do this for you.
Challenge
Write a program or function that takes in a single integer T and a list of integers. If the running sum of the list of integers is ever less than T, then print or return a falsy value, otherwise print or return a truthy value.
You may use any usual input methods (stdin, from file, command line, arguments to function).

At the start of the list the running sum is 0. So a positive T means the result is always falsy.
+ will never be in front of positive integers.
The list may contain 0.
The list may be empty.

Test Cases
T is -5 in all of these.
Falsy:
-6
1
2
3
-20
200
-300
1000
Truthy:
[empty list]
-5
4
-3
-6

Scoring
The submission with the fewest bytes wins. Tiebreaker goes to earliest posted submission.
The regrettable comment that forced me to make this.

Test case needed T=5, L=[10]. Maybe I completely missed the point

@edc65 "At the start of the list the running sum is 0. (So a positive T means the result is always falsy.)"

@optimizer don't be sad, i got your reference <3

@undergroundmonorail too late. And there's a link in there.

gs2 - 6 bytes
Assume the list is on top of the stack, and the threshold is in register A. In mnemonics:
inits
sum get-a lt filter3
not

In bytecode:
78 64 D0 70 F2 22

Is this really the function equivalent in gs2? Basically, can you justify your assumptions a bit more? (I will likely accept if you do.)

gs2 doesn't really have functions, but you can put some code in a block, push it on top of the stack, and call eval on it, just like in GolfScript. If you put these six bytes in a block and eval them in the situation I described, the list on top of the stack will get replaced with the answer (0 for false, 1 for true). Likewise if you just prefix this code with some code that pushes a list and assigns a threshold to register A, you will get the correct result.

It works in a pretty similar way as other solutions. inits is like in Haskell: "abcd" inits → ["" "a" "ab" "abc" "abcd"] gets us all the prefixes. Then we filter with a "lambda" of three commands, which is __ __ __ F2 in bytecode: we look for all the prefixes of which the sum is less than whatever is in A. Then not determines whether the list is empty.

Haskell, 22 bytes
f t=all(>=t).scanl(+)0

Usage: f (-5) [4,-3,-6] which outputs True.
Make a list of sub-totals and check if all elements are >= t.
Edit: Bugfix for empty list and positive ts

@MartinBüttner: The initial 0 is not in the list, as scanl1 returns the empty list if feeded with the empty list, but all catches that case. f (-5) [] returns True.

@MartinBüttner: Oops, you're right. Missed that case and fixed it. Thanks!

Python 2, 41
f=lambda a,t:t<=0<(a and f(a[1:],t-a[0]))

The first argument is the array; the second is the minimum running total.

J, 11 bytes
   */@:<:0,+/\

Tests
   _5 (*/@:<:0,+/\)  1 2 3 _20
0
   _5 (*/@:<:0,+/\)  >a: NB. empty list
1

1-byte improvement thanks to FUZxxl.
Explanation for the original version (*/@(<:0,+/\))

+/\ creates a running sum (sum +/ of prefixes \)
0,+/\ appends a 0 to the running sum
(<:0,+/\) left side input smaller or equal <: than (elements of of the) result of 0,+/\ on the right side input
@ with the previous result
*/ product of all elements (1 if all elements are 1, 0 if an element is 0)

You can do */@:<:0,+/\  for one character I think.

APL, 8 10
∧.≤∘(0,+\)

This is a function that takes T as its left argument and the list as its right argument.

0,+\: running sum of right argument, appended to a 0
∧.≤: left argument smaller or equal (≤) than all (∧) items in the right argument

I also tried this but, "So a positive T means the result is always falsy."

@user23013: damn it. well, it's fixed now but it won't win.

Mathematica, 34 bytes
FreeQ[Accumulate@{0,##2},n_/;n<#]&

This defines an unnamed variadic function which take T as the first parameter and the transactions as the remaining parameters, and returns a boolean:
FreeQ[Accumulate@{0,##2},n_/;n<#]&[-5, 1, 2, 3, -20]
(* False *)

I like this because I could make use of the rather rare ##2 which "splats" all arguments from the second into the list. For more details see the last section in this golfing tip.

Prelude, 144 136 bytes
This was... hard...
?
?(1- )v1+(1-
 ^    #       1) v #  -)1+(#
  v#         vv (##^v^+
   ^?+     v-(0## ^ #   01 #)(#)#
1         v#                  # )!

I think 6 voices is a new record for me, although I'm sure there's a way to reduce that and get rid of lots of that annoying whitespace. Checking the sign of a value (and therefore, checking whether one value is greater than another) is quite tricky in Prelude.
Input and output is given as byte values. When you use the Python interpreter, you can set NUMERIC_OUTPUT = True, so that you actually get an ASCII 0 or 1. For numeric input, you'd have to add another NUMERIC_INPUT flag (I should probably publish my tweaked interpreter at some point).
Also note that Prelude cannot really distinguish the end of a list from a 0 within the list. So in order to allow zero transactions, I'm reading T, then the length L of the list, and then L transactions.

k, 8 char
A dyadic verb taking the threshold as the first argument and the list as the second. Remarkably, this works in every version of k, including the open-source Kona.
&/~0<-\,

In k, composition of functions is just done by writing one and then the other, so we can break this up by functions. From right to left:

-\, takes successive running sums and subtracts them from the threshold. (If f is dyadic, then f\ (a; b; c; ...)  expands to (a; a f b; (a f b) f c; ...). , just joins lists together.) Breaking even occurs when something is equal to 0, and overdrawing gives strictly positive values.
~0< is Not 0 Less-Than. k doesn't really have a greater-than-or-equal-to <= operator, so we have to throw boolean NOT on a less-than, but this tests for whether the result is nonpositive. It automatically applies to each atom in the list.
&/ is the fold of logical AND over a list. (For f dyadic) So this tests whether every boolean in the list is True.

Examples:
  (&/~0<-\,)[-5; 1 2 3 -20]
0
  f:&/~0<-\,  /assign to a name
  f[-5; 4 -3 -6]
1

I'd probably add 2 chars for the parantheses. And you can shave 1 char off if you do ~|/>+\,

@tmartin Monadic > is "descending sort permutation" so ~|/>+\, gives true only when the input list is empty...

Ah you're right, my mistake.

CJam, 17 bytes
l~0\{1$+}%+\f<:+!

Takes input as an integer and a CJam-style array on STDIN:
-5 [1 2 3 -20]

Test it here.

Pyth, 16 15
!sm>vzs+0<QdhlQ

Try it online with the input
-5
[4, -3, 6]

Explanation:
                   Implicit: z and Q read 2 line from input
                   z = "-5" (this is not evaluated, it's a string)
                   Q = [4, -3, 6] (this is a list though)
 m         hlQ     map each number d in [0, 1, 2, ..., len(Q)] to:
  >vz                 the boolean value of: evaluated z >
     s+0<Qd                                 the sum of the first d elements in Q
!s                  print the boolen value of: 1 > sum(...)

And again the stupid s function wastes two bytes. I think I'm gonna report this as a bug to the Pyth repo.
edit: 13 (not valid)
Thanks to isaacg for one byte save (>1 to !) and for changing the implementation of s in the Pyth repo. Now the following code is possible (but of course not valid for this challenge).
!sm>vzs<QdhlQ

I use them pretty often. See here: http://codegolf.stackexchange.com/questions/45264/fill-in-the-blanks/45276#45276. It would save 2 characters in this case, but lose 5 characters in the list of lists case. I see if there's an unused letter to separate these into two different functions, though. Also, you could save a character by using ! instead of >1.

@isaacg Defining the sum of an empty list as 0 (almost) doesn't break any existing Pyth code. The only code it would break is #sY.
And thanks for the 1 byte save.

I suppose that's fair - throwing exceptions doesn't help anyone. Fixed.

R, 35
function(t,l)all(cumsum(c(0,l))>=t)

Try it here

Julia, 33 bytes
(T,l)->all(i->i>=T,cumsum([0,l]))

This creates an unnamed function that accepts two parameters, T and l, and returns a boolean.
The all() function does all of the heavy lifting here. It takes two arguments: a predicate and an iterable. For the predicate, we tell it that i represents the current value of the iterable using an unnamed function, specified by i->. Then at each iteration we compare i to T using i>=T.
To make sure that Julia doesn't freak out about using cumsum() on an empty list, we can tack a zero on there using [0, l].

Python 2.7 - 55 bytes
f=lambda T,l:all(T<=sum(l[:i])for i in range(len(l)+1))

Call like print f(-5,[1,2,3,-20]). Test it here.
Thanks to Jakube for helping.

CJam, 18 bytes
Another approach in same bytes as the other one.
q~_,),\f<1fb:)f<:&

Takes input via STDIN in the form of <threshold> <array of transactions>
Try it online here

I think you can use f>:|! instead of :)f<:&

JavaScript (ES6) 38 33
Edit Fixed initial balance bug. Thx @martin & @rainbolt
F=(t,l)=>![r=0,...l].some(v=>(r+=v)<t)

Test In Firefox/FireBug console
console.log(F(-5,[-6]),F(-5,[1,2,3,-20]),F(-5,[200,-300,1000]))
console.log(F(-5,[]),F(-5,[-5]),F(-5,[4,-3,-6]))
console.log(F(5,[10]),F(5,[]))

false false false
true true true
false false

The initial balance is zero. The first deposit is 10, but we are already below our threshold before the first deposit ever makes it to the bank.

><>, 29 + 3 = 32 bytes
r0}&v >1n;n0<
&:&:<+^?=1l ^?(

Run like
py -3 fish.py bookkeep.fish -v -5 4 3 -6

where the threshold is the first number.

Octave, 27
@(t,l)all(cumsum([0,l])>=t)

Perl 6 (21 bytes)
{$^a>none [\+] 0,@^b}

It's a function taking initial argument, and list of elements. It works by checking if none (by using junctions) of elements are below the threshold. [\+] is used for generating running sum, for example [\+] 1, 2, 3 gives 1, 3, 6. 0, to append 0 at beginning of list is needed because of requirement that positive threshold always should fail.
Pretty much the same thing as Haskell solution, just in Perl 6 syntax (Perl 6 took so many neat programming features from Haskell).

Perl - 20
Take the list of numbers on STDIN seperated by newlines and take T with the -i flag.
die if$^I>($i+=$_)

+2 for -i and -n flags. The exit value is 255 for failures and 0 on success.
Run with:
echo -e "4\n3\n-6" | perl -i0 -ne'die if$^I>($i+=$_)'

Clojure, 45
(fn[T t](every? #(<= T %)(reductions + 0 t)))

E.g.
((fn[T t](every? #(<= T %)(reductions + 0 t))) -5 [1 2 3 -20])
;; =>false

Or a lil' nicer;
(defn f[T t](every? #(<= T %)(reductions + 0 t)))

(testing
  (testing "tests from question"
    (is (false? (f -5 [-6])))
    (is (false? (f -5 [1 2 3 -20])))
    (is (false? (f -5 [200 -300 1000])))
    (is (true? (f -5 [-5])))
    (is (true? (f -5 [4 -3 -6])))
    (is (true? (f -5 []))))
  (testing "the start of the list the running sum is 0. So a positive T means the result is always falsy"
    (is (false? (f 5 [5])))
    (is (false? (f 5 [10])))
    (is (false? (f 5 [])))))

Java 8 - 153 chars
Golfed function:
import java.util.stream.*;
boolean f(int t, IntStream s){int r=1;try{s.reduce(0,(a,b)->(a+b>=t)?(a+b):(a/(a-a)));}catch(Exception e){r=0;}return r==1;}

Ungolfed:
import java.util.stream.*;

boolean f(int t, IntStream s) {
    int r=1;
    try {
        s.reduce(0,(a,b) -> (a+b>=t) ? (a+b) : (a/(a-a)));
    } catch(Exception e) {
        r=0;
    }

    return r==1;
}

Driver program:
import java.util.stream.*;
import java.util.*;

public class A {
    // function f as above

    public static void main(String... args) {
        int t = -5;
        IntStream s = null;

        s = Arrays.asList(-6).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(1,2,3,-20).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(200,-300,1000).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        System.out.println("above false, below true");

        s = IntStream.empty();
        System.out.println(new A().f(t,s));

        s = Arrays.asList(4,-3,-6).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(-5).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));
}

}
Output:
bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true

Jelly, 4 bytes
Ä<Ẹ¬

Try it online!
Outputs 0 for falsey and 1 for truthy. The final byte can be removed if the outputs can be flipped.
I decided to put this through a basic brute-forcer to try to get a 3 byte solution. Any such solution would have to be in the form Ä<X, where X is an unknown atom. This Jelly program iterates through all atoms (ones that lead to errors were removed), inserts them into the template above and tests whether the atom gives the desired results for the inputs. If it does, it should output 1. The final number is the number of successes, which is unfortunately 0. However, if we change the template to mirror the above program (4 bytes), we get 7 results:
Ä<S¬
Ä<Ḅ¬
Ä<Ḍ¬
Ä<Ẹ¬
Ä<Ṁ¬
Ä<§¬

I've excluded Ä<V¬ due to the extra output it produces
How it works
Ä<Ẹ¬ - Main link. Takes L on the left and T on the right
Ä    - Cumulative sum of L
 <   - Is each less than T?
       This yields all 0s for a truthy input and at least 1 1 otherwise
  Ẹ  - Is there a 1?
   ¬ - Logical NOT

Japt, 6 bytes
å+ e¨V

Try it here

Husk, 5 bytes
Λ>⁰∫²

Try it online!
Not sure how to remove the superscripts, but it should be possible.