text:
Put on your sunglasses
Introduction
You are probably familiar with the "puts on sunglasses" emoticon-meme:
(•_•)
( •_•)>⌐■-■
(⌐■_■)

In this challenge, your task is to take the first line as input, and output the last one, effectively putting sunglasses on that little button-eyed person.
To make the task a bit more difficult, the characters have been scaled up and converted to (ugly) ASCII art.
Input
Your input is exactly this multi-line string, with an optional trailing newline:
   r                       t
  /                         \
 :                           :
 /    ,##.           ,##.    \
|     q##p           q##p     |
|      **             **      |
 \                           /
 :                           :
  \                         /
   L      ##########       j

Output
Your output is exactly this multi-line string, again with an optional trailing newline:
   r                                         t
  /                                           \
 :               ______             ______     :
 /              |######|           |######|    \
|     _______   |######|           |######|     |
|     #""""""   |######|           |######|     |
 \    #         |######|           |######|    /
 :    "          """"""             """"""     :
  \                                           /
   L                    ##########           j

Note that there are no trailing spaces in the input and output.
Rules and scoring
You can write a full program or a function.
The lowest byte count wins, and standard loopholes are disallowed.

Is this really intended to be a [tag:kolmogorov-complexity] question, meaning that any parsing of the input is not required and code that prints that particular output regardless of its input is ok?

@ppperry Ignoring the input is a valid strategy, yes. Your program may even crash if given any other input that that particular string. My intention was to have a "conditional Kolmogorov complexity" challenge: the task is to produce a fixed output, and you are also given access to some fixed auxiliary data that may or may not be helpful. I think giving the data as input is the cleanest way to do it (as opposed to something like "if this string appears verbatim in your source, subtract its length from your score").

Bubblegum, 97 bytes
0000000: e001 e500 595d 0010 6818 841b 8ec4 c1cd  ....Y]..h.......
0000010: edc4 82fe b74a b6dd affc 98aa dccc 0d35  .....J.........5
0000020: 6869 7333 10ec f862 efbc 1475 9496 cacf  his3...b...u....
0000030: 5379 f091 507e 3df4 4a1d 51fc 98f7 4fb8  Sy..P~=.J.Q...O.
0000040: a8e0 2e3e 3b1b dc32 cbcf 5f0c d010 9d96  ...>;..2.._.....
0000050: 63e9 c49a fc44 60ef 7680 9b58 9027 c000  c....D`.v..X.'..
0000060: 00

Compressed using LZMA. Try it online.

-1 byte

Retina, 210 161 156 133 bytes (ISO 8859-1 encoding)
Completely remade, doesn't care about input anymore.
s`.+
3r41t¶2/43\¶1:15,13,5:¶1/10 e\¶|5_,e |¶|5#'e |¶1\4#5 e/¶1:4"10'13'5:¶2\43/¶3L19 10$*#11j
e
3~11~4
~
|6$*#|
,
6$*_
'
6$*"
\d+
$*

There is a trailing space at the end of last line. Also, a trailing newline is included in the output. If you want to suppress it, change the second last line to \`\d+
Old version, which uses parts of input in output:
( {3})(.+¶){3}.{10}( +)\S+( +).¶.( +)(.+¶){5}.+?(#+).+
$1rq te /q$1\e:pf,p$1,f:e/p$4~$3~$4\¶|f,_$1~$3~f|¶|f#'$1~$3~f|e\$4#$4f~$3~$4/e:$4"p'p$1'f:e \q$1/¶$1Lpp$7$3j
~
|6$*#|
,
6$*_
'
6$*"
q
pppp
p
ff
e
¶
f
5$*

Try it online! (210-byte version)
Try it online! (161-byte version)
Try it online! (156-byte version)
Try it online! (133-byte version)

JavaScript (ES6), 200 bytes
a=>a.split`
`.map((l,i)=>l[s="slice"](0,6)+(["_7 3",'#"6 3',"# 9",'" 9'][i-4]||"  9")+(g=[" _5 ",x="|#5|",x,x,x,' "5 '][i-2]||" 7")+l[s](10,21)+g+l[s](25)).join`
`.replace(/.\d/g,m=>m[0].repeat(m[1]))

Explanation
Replaces the eyes of the input with run-length encoded glasses, then decodes them.

var solution =

a=>
  a.split`
`.map((l,i)=>                                      // for each line of the input
    l[s="slice"](0,6)                              // left outline
    +(["_7 3",'#"6 3',"# 9",'" 9'][i-4]||"  9")    // glasses frame
    +(g=[" _5 ",x="|#5|",x,x,x,' "5 '][i-2]||" 7") // left glasses lens
    +l[s](10,21)                                   // mouth
    +g                                             // right glasses lens
    +l[s](25)                                      // right outline
  )
  .join`
`                                                  // combine altered lines
  .replace(/.\d/g,m=>m[0].repeat(m[1]))            // run-length decoding

result.textContent = solution(
`   r                       t
  /                         \\
 :                           :
 /    ,##.           ,##.    \\
|     q##p           q##p     |
|      **             **      |
 \\                           /
 :                           :
  \\                         /
   L      ##########       j`
);

Python 3, 283 bytes
import zlib;print(zlib.decompress('x\x9cSPP(R \x16\x94p)(è\x13\xadZA!\x86KÁ\nM(\x1e\x0cp\tYq¡\x9b_£\x0c\x0658\x84b¸j\x90Ì\x88\'¬A¡\x06ªCY\t\x0c\x88Ò¡\x10\x03ÖA¬£ô¡ÞVBHÃ-Ã*\x04ô6Ä\n"\x01Ð\x02\x05\x05\x1fl2Êp\x80$\x98\x05\x00ð>KB\n'.encode('latin-1')).decode())

Try it online
Doing the encoding and decoding to deal with the fact that zlib.decompress expects a bytes object is about 30 bytes cheaper than just directly passing a bytes object:
import zlib;print(zlib.decompress(b'x\x9cSPP(R \x16\x94p)(\xe8\x13\xadZA!\x86K\xc1\nM(\x1e\x0cp\tYq\xa1\x9b_\xa3\x0c\x0658\x84b\xb8j\x90\xcc\x88\'\xacA\xa1\x06\xaaCY\t\x0c\x88\xd2\xa1\x10\x03\xd6A\xac\xa3\xf4\xa1\xdeVBH\xc3-\xc3*\x04\xf46\xc4\n"\x01\xd0\x02\x05\x05\x1fl2\xcap\x80$\x98\x05\x00\xf0>KB').decode())

05AB1E Osable, 174 bytes
Well, this was a mistake... 05AB1E doesn't have any compression built-in except for a dictionary compression method. Code:
2FSð18×sJ,}17÷\?'_6×Dð13×sð5×VY':J,ð'/ð14×J?'|'#6×'|JDð11×sð4×JUX'\J,'|Y'_7×ð3×Xð'|J,'|Y'#'"6×ð3×Xð'|J,ð'\ð4×'#ð9×X'/J,ð':ð4×'"ðT×'"6×Dð13×sY':J,\\\\\Sð18×sJ,5÷ð4×srð14×srJ?,

Try it online!
Uses CP-1252 encoding.

Python 2, 120 bytes
This source contains non-printable characters, so it is presented as a hexdump that can be decoded with xxd -r.
00000000: efbb bf70 7269 6e74 2778 018d cea7 1503  ...print'x......
00000010: 310c 5c30 50ae 29fe 3b0f 60ee 19b2 411a  1.\0P.).;.`...A.
00000020: 0f4b 81de 3dbd b7d3 67ea c246 d62e a8f2  .K..=...g..F....
00000030: 66a1 79b5 3cfb 956a a17a d1cb 59ff 919a  f.y.<..j.z..Y...
00000040: 4507 cb8b f101 3d3a 28c3 596a c20c 4af6  E.....=:(.Yj..J.
00000050: a91a 1a0c eeee c7be a65a 3093 5703 135f  .........Z0.W.._
00000060: 943b 0fab 03f0 3e4b 4227 2e64 6563 6f64  .;....>KB'.decod
00000070: 6528 277a 6970 2729                      e('zip')

Vyxal, 214 bytes
3\r꘍41\t꘍+,2\/꘍43\\꘍+,1\:꘍2꘍13\_6*꘍d5\:꘍Wṅ,1\/꘍3꘍11\|\#3*+m꘍d4\\꘍Wṅ,\|5꘍\_7*`   |###`m3꘍øm2\|꘍Wṅ,\|5꘍\#\"6*`   |###`m3꘍øm2\|꘍Wṅ,1\\꘍4\#꘍ð6*`   |###`m3꘍øm1\/꘍Wṅ,1\:꘍4\"꘍₀\"6*3꘍꘍d2\:꘍Wṅ,2\\꘍43\/꘍+,3\L꘍20\#₀*꘍11\j꘍++,

Try it Online!
A hardcoding mess.


text:
Taxi me some numbers
Taxicab Numbers or OEIS A011541 are the least numbers that are able to be represented as \$n\$ different sums of two positive cubed integers, for successive \$n\$.
You'll need to print out the \$n\$th taxicab number. This should work for any \$n\$ in theory.
However, as only 6 taxicab numbers have been discovered so far, there won't be an \$n\$ above 6. The numbers are \$2, 1729, 87539319, 6963472309248, 48988659276962496\$ and \$24153319581254312065344\$.
You're not allowed to hard code these variables, because your program must work for any arbitrary \$n\$ in theory.

Does this require we support numbers of arbitrary length? If we can only handle values up to 2^32-1 but the program would work for larger values if only they were allowed, is that OK?

Sure, that's fine with me. As long as the algorithm itself would work for any number, you're good.

Haskell, 60 bytes
f n=[k|k<-[0..],n<=sum[1|x<-[1..k],y<-[1..x],x^3+y^3==k]]!!0

Pretty straightforward. Counts how many ways a number k can be written as a sum of two cubes. Filters for k's such that this number is at least n, and takes the first one.
An equal-length method with until:
f n=until(\k->n<=sum[1|x<-[1..k],y<-[1..x],x^3+y^3==k])(+1)0

Your program produces the smallest number that's a sum of two cubes in n different ways. The problem asks to find the n'th number which is a sum of two cubes in two different ways.

@ItaiBar-Natan It looks to me like the spec is asking for the least number that's a sum of two cubes in n different ways.

Oops, I just reread the problem and I think you're right. I guess I misread it incorrectly.

Taxi, 4758 bytes
What better language to calculate taxicab numbers than one that simulates taxicabs?
This is a joke. There are so many better languages. What happened to the last two days of my life?
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l 2 r.Pickup a passenger going to Bird's Bench.Pickup a passenger going to Cyclone.Go to Zoom Zoom:n.Go to Cyclone:w.Pickup a passenger going to Rob's Rest.Pickup a passenger going to Cyclone.Go to Bird's Bench:n 1 r 2 r 1 l.Go to Rob's Rest:n.Go to Cyclone:s 1 l 1 l 2 l.[a]Pickup a passenger going to Firemouth Grill.Pickup a passenger going to The Underground.Go to Zoom Zoom:n.Go to Firemouth Grill:w 3 l 2 l 1 r.Go to The Underground:e 1 l.Switch to plan "b" if no one is waiting.Pickup a passenger going to Cyclone.Go to Cyclone:n 3 l 2 l.Switch to plan "a".[b]Go to Firemouth Grill:s 1 r.[c]Pickup a passenger going to Cyclone.Go to Cyclone:w 1 l 1 r 2 r.Pickup a passenger going to Cyclone.Go to Zoom Zoom:n.Go to Cyclone:w.Pickup a passenger going to Multiplication Station.Pickup a passenger going to Multiplication Station.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:s 1 l 2 r 4 l.Pickup a passenger going to Trunkers.Go to Trunkers:s 1 r 2 l.Go to Firemouth Grill:e 1 l 1 r.Switch to plan "e" if no one is waiting.Switch to plan "c".[e]Go to Trunkers:w 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:w 2 r.Pickup a passenger going to Sunny Skies Park.Go to Sunny Skies Park:n 1 r.[f]Go to Trunkers:s 1 l.Switch to plan "g" if no one is waiting.Pickup a passenger going to Sunny Skies Park.Go to Cyclone:w 2 r.Pickup a passenger going to Cyclone.Go to Zoom Zoom:n.Go to Cyclone:w.Go to Sunny Skies Park:n 1 r.Switch to plan "f".[g]Go to Cyclone:w 2 r.Switch to plan "h" if no one is waiting.Pickup a passenger going to Firemouth Grill.Go to Zoom Zoom:n.Go to Firemouth Grill:w 3 l 2 l 1 r.Go to Trunkers:w 1 l 1 r.Switch to plan "g".[h]Go to Sunny Skies Park:n 1 r.Switch to plan "i" if no one is waiting.Pickup a passenger going to Cyclone.Go to Firemouth Grill:s 1 l 1 l 1 r.Pickup a passenger going to Addition Alley.Go to Cyclone:w 1 l 1 r 2 r.Pickup a passenger going to Addition Alley.Pickup a passenger going to Trunkers.Go to Zoom Zoom:n.Go to Trunkers:w 3 l.Go to Addition Alley:w 2 r 2 r 1 r.Pickup a passenger going to Narrow Path Park.Go to Narrow Path Park:n 1 r 1 l 1 r.Go to Cyclone:w 1 l 1 r 2 l.Switch to plan "h".[i]Go to Trunkers:s 1 l.Pickup a passenger going to Knots Landing.Go to Knots Landing:e 1 r 2 l 5 r.Go to Trunkers:w 1 l 3 r 1 l.Switch to plan "j" if no one is waiting.Go to Firemouth Grill:e 1 l 1 r.Switch to plan "e".[j]0 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 l 2 l.Pickup a passenger going to Addition Alley.[k]Go to Rob's Rest:w 1 r 2 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:s 1 l 1 l 2 l.Pickup a passenger going to Rob's Rest.Pickup a passenger going to Equal's Corner.Go to Zoom Zoom:n.Go to Rob's Rest:w 2 l 2 r 1 r.Go to Narrow Path Park:s 1 l 1 l 1 r 1 r 2 l 5 l.Switch to plan "o" if no one is waiting.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:w 1 l 1 r 2 l 1 l.Switch to plan "l" if no one is waiting.Pickup a passenger going to Knots Landing.1 is waiting at Starchild Numerology.Switch to plan "m".[l]0 is waiting at Starchild Numerology.[m]Go to Starchild Numerology:n 1 r.Pickup a passenger going to Addition Alley.Go to Addition Alley:w 1 r 3 r 1 r 1 r.Pickup a passenger going to Addition Alley.Go to Knots Landing:n 1 r 2 r 1 l.Go to Starchild Numerology:w 1 l 3 r 1 l 1 l 2 l.Switch to plan "k".[o]0 is waiting at Starchild Numerology.Go to Starchild Numerology:w 1 l 1 r 2 l 1 l 3 l.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:w 1 l.Go to Addition Alley:n 4 r 1 r 1 r.Pickup a passenger going to Equal's Corner.Go to Bird's Bench:n 1 l 1 l 1 l 2 r 1 l.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 r 1 l 2 l.Pickup a passenger going to Bird's Bench.Pickup a passenger going to Equal's Corner.Go to Bird's Bench:n 1 r 2 r 1 l.Go to Equal's Corner:n 1 r 1 r.Switch to plan "p" if no one is waiting.Go to Starchild Numerology:n 1 r.Go to Rob's Rest:w 1 r 2 l 1 r.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 l 1 r 1 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.Switch to plan "z".[p]1 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 r.Pickup a passenger going to Addition Alley.Go to Rob's Rest:w 1 r 2 l 1 r.Pickup a passenger going to Addition Alley.Go to Addition Alley:s 1 l 1 l 2 r 1 r 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l.Pickup a passenger going to Rob's Rest.Pickup a passenger going to Cyclone.Go to Rob's Rest:n 1 r 2 r 1 r.Go to Cyclone:s 1 l 1 l 2 l.Switch to plan "a".[z]

Try it online!
Try it online but with comments and line breaks!
Note: TIO can handle an input of 1 but 2 and above cause a timeout issue. I wrote a little snippet to print the value being checked every iteration and it only got up to 137 before it timed out. If someone who knows what they're doing could run it through an interpreter (the homepage links to a C++ version) to verify higher values, I'd appreciate it. It may take a very long time to run.
Ungolfed with comments:
[ FIND THE NTH TAXI CAB NUMBER ]
[ https://en.wikipedia.org/wiki/Taxicab_number ]
[ Inspired by https://codegolf.stackexchange.com/q/73827/38183 ]

[ A taxi cab number T(n) is the smallest number that can be made from the sum  ]
[ of two positive cubes in n different ways. For example, T(1) = 2 because     ]
[ 2 = 1^3 + 1^3. That is the only way to make 2 by summing positive cubes. No  ]
[ solution exists for 1 so 2 is T(1). T(2) = 1729 = 1^3 + 12^3 = 9^3 + 10^3.   ]
[ This program takes n as input and finds T(n). The (bad) psuedocode is:       ]
[                                                                              ]
[    S = STDIN;  // Use Bird's Bench                                           ]
[    T = STDIN;  // Use Rob's Rest. Saves bytes and T(n) > n is always true.   ]
[    while (true) {                                                            ]
[       // Fill an array (Firemouth Grill) with the numbers 1 through T        ]
[       // This will make it much easier to compute the cubes because a taxi   ]
[       // can only carry three passengers at a time.                          ]
[       for (i = T; i > 0; i--) { A.push(i) }                                  ]
[       // Fill an array (Trunkers) with the cubes of all integers 1 through T ]
[       for (i = T; i > 0; i--) { B.push(i ^ 3) }                              ]
[       // Fill an array (Sunny Skies Park) with each possible sum of cubes    ]
[       while (B(0) != null) {                                                 ]
[          // Make copies of the next value to add to each remaining value     ]
[          C.push(B(0));                                                       ]
[          while (B(0) != null) {                                              ]
[             C.push(C(0));                                                    ]
[             D.push(B(0));                                                    ]
[             B.shift();                                                       ]
[          }                                                                   ]
[          // Store each possible sum with this cube                           ]
[          while (C(0) != null) {                                              ]
[             E.push(C(0) + D(0));                                             ]
[             B.push(D(0));                                                    ]
[             C.shift;                                                         ]
[             D.shift;                                                         ]
[          }                                                                   ]
[       }                                                                      ]
[       // Check each possible sum to see if it equals T                       ]
[       N = 0;                                                                 ]
[       while (D(0) != null) {                                                 ]
[          if (D(0) = T) { N++ }                                               ]
[          D.shift();                                                          ]
[       }                                                                      ]
[       // If we found the desired number of sums, ouput and break             ]
[       // Otherwise, go to the next T and keep going                          ]
[       if (N = S) {                                                           ]
[          print(T);                                                           ]
[          break;                                                              ]
[       } else {                                                               ]
[          T++;                                                                ]
[       }                                                                      ]
[    }                                                                         ]
[                                                                              ]

[ S = STDIN;  // Use Bird's Bench                                         ]
[ T = STDIN;  // Use Rob's Rest. Saves bytes and T(n) > n is always true. ]
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left 2nd right.
Pickup a passenger going to Bird's Bench.
Pickup a passenger going to Cyclone.
Go to Zoom Zoom: north.
Go to Cyclone: west.
Pickup a passenger going to Rob's Rest.
Pickup a passenger going to Cyclone.
Go to Bird's Bench: north 1st right 2nd right 1st left.
Go to Rob's Rest: north.

[ // Fill an array (Firemouth Grill) with the numbers 1 through T      ]
[ // This will make it much easier to compute the cubes because a taxi ]
[ //  can only carry three passengers at a time.                       ]
[ for (i = T; i > 0; i--) { A.push(i) }                                ]
Go to Cyclone: south 1st left 1st left 2nd left.
[a]
Pickup a passenger going to Firemouth Grill.
Pickup a passenger going to The Underground.
Go to Zoom Zoom: north.
Go to Firemouth Grill: west 3rd left 2nd left 1st right.
Go to The Underground: east 1st left.
Switch to plan "b" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 3rd left 2nd left.
Switch to plan "a".

[b]
[ // Fill an array (Trunkers) with the cubes of all integers 1 through T ]
[ for (i = T; i > 0; i--) { B.push(i ^ 3); }                             ]
Go to Firemouth Grill: south 1st right.
[c]
Pickup a passenger going to Cyclone.
Go to Cyclone: west 1st left 1st right 2nd right.
Pickup a passenger going to Cyclone.
Go to Zoom Zoom: north.
Go to Cyclone: west.
Pickup a passenger going to Multiplication Station.
Pickup a passenger going to Multiplication Station.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station: south 1st left 2nd right 4th left.
Pickup a passenger going to Trunkers.
Go to Trunkers: south 1st right 2nd left.
Go to Firemouth Grill: east 1st left 1st right.
Switch to plan "e" if no one is waiting.
Switch to plan "c".

[e]
[ // Fill an array with each possible sum of cubes                ]
[ while (B(0) != null) {                                          ]
[ // Make copies of the next value to add to each remaining value ]
[ C.push(B(0));                                                   ]
[ while (B(0) != null) {                                          ]
[    C.push(C(0));                                                ]
[    D.push(B(0));                                                ]
[    B.shift();                                                   ]
[ }                                                               ]
[ Setup Cyclone with a copy of the first value ]
Go to Trunkers: west 1st left 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: west 2nd right.
Pickup a passenger going to Sunny Skies Park.
Go to Sunny Skies Park: north 1st right.

[f]
[ Move any remaining values to Sunny Skies Park, duplicating Cyclone each time ]
Go to Trunkers: south 1st left.
Switch to plan "g" if no one is waiting.
Pickup a passenger going to Sunny Skies Park.
Go to Cyclone: west 2nd right.
Pickup a passenger going to Cyclone.
Go to Zoom Zoom: north.
Go to Cyclone: west.
Go to Sunny Skies Park: north 1st right.
Switch to plan "f".

[g]
[ // Store each possible sum with this cube ]
[ while (C(0) != null) {                    ]
[    E.push(C(0) + D(0));                   ]
[    B.push(D(0));                          ]
[    C.shift;                               ]
[    D.shift;                               ]
[ }                                         ]
[ Move everything at Cyclone to Firemouth Grill ]
Go to Cyclone: west 2nd right.
Switch to plan "h" if no one is waiting.
Pickup a passenger going to Firemouth Grill.
Go to Zoom Zoom: north.
Go to Firemouth Grill: west 3rd left 2nd left 1st right.
Go to Trunkers: west 1st left 1st right.
Switch to plan "g".

[h]
[ Copy Sunny Skies Park to Trunkers and add it to Firemouth Grill ]
Go to Sunny Skies Park: north 1st right.
Switch to plan "i" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Firemouth Grill: south 1st left 1st left 1st right.
Pickup a passenger going to Addition Alley.
Go to Cyclone: west 1st left 1st right 2nd right.
Pickup a passenger going to Addition Alley.
Pickup a passenger going to Trunkers.
Go to Zoom Zoom: north.
Go to Trunkers: west 3rd left.
Go to Addition Alley: west 2nd right 2nd right 1st right.
Pickup a passenger going to Narrow Path Park.
Go to Narrow Path Park: north 1st right 1st left 1st right.
Go to Cyclone: west 1st left 1st right 2nd left.
Switch to plan "h".

[i]
[ } // End of 'while (B(0) != null)' up near plan "e" ]
Go to Trunkers: south 1st left.
Pickup a passenger going to Knots Landing.
Go to Knots Landing: east 1st right 2nd left 5th right.
Go to Trunkers: west 1st left 3rd right 1st left.
Switch to plan "j" if no one is waiting.
Go to Firemouth Grill: east 1st left 1st right.
Switch to plan "e".

[j]
[ // Check each possible sum to see if it equals T ]
[ N = 0;                                           ]
[ while (D(0) != null) {                           ]
[    if (D(0) = T) { N++; }                        ]
[    D.shift();                                    ]
[ }                                                ]
[ Set N = 0 ]
0 is waiting at Starchild Numerology.
Go to Starchild Numerology: west 1st left 2nd left.
Pickup a passenger going to Addition Alley.

[k]
[ Pickup T ]
Go to Rob's Rest: west 1st right 2nd left 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: south 1st left 1st left 2nd left.
Pickup a passenger going to Rob's Rest.
Pickup a passenger going to Equal's Corner.
Go to Zoom Zoom: north.
Go to Rob's Rest: west 2nd left 2nd right 1st right.
Go to Narrow Path Park: south 1st left 1st left 1st right 1st right 2nd left 5th left.
Switch to plan "o" if no one is waiting.

[ Check the next value against T ]
Pickup a passenger going to Equal's Corner.
Go to Equal's Corner: west 1st left 1st right 2nd left 1st left.
Switch to plan "l" if no one is waiting.

[ It's a match so N = N + 1 ]
Pickup a passenger going to Knots Landing.
1 is waiting at Starchild Numerology.
Switch to plan "m".

[l]
[ It's not a match so N = N + 0 ]
0 is waiting at Starchild Numerology.

[m]
Go to Starchild Numerology: north 1st right.
Pickup a passenger going to Addition Alley.
Go to Addition Alley: west 1st right 3rd right 1st right 1st right.
Pickup a passenger going to Addition Alley.
Go to Knots Landing: north 1st right 2nd right 1st left.
Go to Starchild Numerology: west 1st left 3rd right 1st left 1st left 2nd left.
Switch to plan "k".

[o]
[ // If we found the desired number of sums, ouput and break ]
[ // Otherwise, go to the next T and keep going              ]
[ if (N = S) {                                               ]
[    print(T);                                               ]
[    break;                                                  ]
[ } else {                                                   ]
[    T++;                                                    ]
[ }                                                          ]
[ T is still going to Equal's Corner so just get rid of it ]
0 is waiting at Starchild Numerology.
Go to Starchild Numerology: west 1st left 1st right 2nd left 1st left 3rd left.
Pickup a passenger going to Equal's Corner.
Go to Equal's Corner: west 1st left.

[ N is still going to Addition Alley so redirect it to Equal's Corner ]
Go to Addition Alley: north 4th right 1st right 1st right.
Pickup a passenger going to Equal's Corner.

[ Compare N = S ]
Go to Bird's Bench: north 1st left 1st left 1st left 2nd right 1st left.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st right 1st left 2nd left.
Pickup a passenger going to Bird's Bench.
Pickup a passenger going to Equal's Corner.
Go to Bird's Bench: north 1st right 2nd right 1st left.
Go to Equal's Corner: north 1st right 1st right.
Switch to plan "p" if no one is waiting.

[ It's a match! The value we want is T, waiting at Rob's Rest. ]
[Go to Rob's Rest:n 3 l 1 r.]
Go to Starchild Numerology: north 1st right.
Go to Rob's Rest: west 1st right 2nd left 1st right.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st left 1st right 1st right 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st left 1st right.
Switch to plan "z".

[p]
[ It's not a match. T = T + 1 and start over. ]
1 is waiting at Starchild Numerology.
Go to Starchild Numerology: north 1st right.
Pickup a passenger going to Addition Alley.
Go to Rob's Rest: west 1st right 2nd left 1st right.
Pickup a passenger going to Addition Alley.
Go to Addition Alley: south 1st left 1st left 2nd right 1st right 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left.
Pickup a passenger going to Rob's Rest.
Pickup a passenger going to Cyclone.
Go to Rob's Rest: north 1st right 2nd right 1st right.
Go to Cyclone: south 1st left 1st left 2nd left.
Switch to plan "a".

[z]
[ Terminate program with 10 less bytes than going back to the Taxi Garage ]

I love how insane of a language Taxi is.

@MorganThrapp I hadn't run into this before, but it quickly became an issue that you are able to store a maximum of 6 integer arrays and that's only because Trunkers and Rounders Pub play nicely with integers. If you're storing decimals, you only get 4 arrays. Plus, Firemouth Grill picks up numbers in random order so that's out if you need to maintain order. Really, you only get 2 queues and 1 stack. Good luck.

I'd complain about cheap upvotes given to submissions in funny languages, but this really deserves an upvote anyways.

Jelly, 11 bytes
Œċ*3§ċ⁸=ð1#

Try it online!
This is ridiculously slow, timing out for \$n > 1\$
How it works
Œċ*3§ċ⁸=ð1# - Main link. Takes n on the left
        ð   - Group the previous links into a dyad f(k, n):
Œċ          -   All pairs from [1, 2, ..., k]
  *3        -   Cube each
    §       -   Sum of each
     ċ⁸     -   Count occurrences of k
       =    -   Does that equal n?
         1# - Find the first k, starting with n, which returns true under f(k, n)
              Starting with k = n is fine, as k > n for all n

05AB1E, 15 bytes
∞εL3mãOÙN>¢}Ik>

Try it online!
The program timeouts for \$n>1\$ , but the algorithm works.

ARM Thumb-2, 52 48 bytes for theoretical algorithm, 50 bytes for overflow safe version until n == 3
This one is hilariously inefficient, and only works for n == 3 if we assume infinite integers.
Raw machine code:
b570 2101 0004 000a fb02 f502 4355 0013
fb03 f603 fb06 5603 428e d101 3c01 d005
3b01 d8f5 3a01 d1ef 3101 e7eb 0008 bd70

Assembly:
        .text
        .arch armv6t2
        .thumb
        .globl taxi
        .thumb_func
taxi:
        @ Nickname some registers for clarity
        n .req r0
        candidate .req r1
        i .req r2
        j .req r3
        matches_left .req r4
        i_cubed .req r5
        j_cubed_sum .req r6

        push    {r4-r6, lr}
        @ Start with a candidate of 1 (even though it's impossible)
        movs    candidate, #1
.Lcandidate_loop:
        @ reset match counter
        movs    matches_left, n
        @ start checking cubes
        @ Behold! The world's most inefficient loop!
        @ Takes 1.8 seconds for n = 2 on actual hardware. And remember, this is O(n^3). XD
        @ It also is very vulnerable to integer overflow and returns the incorrect
        @ result for n == 3. However, with sufficiently large integers, it would
        @ theoretically work fine.
        @ for (i = candidate; i != 0; --i)
        movs    i, candidate
.Li_loop:
        @ i_cubed = i * i * i
        mul     i_cubed, i, i                        @ wide insn
        muls    i_cubed, i
        @ for (j = i; --j;)
        movs    j, i
.Lj_loop:
        @ j_cubed_sum = j * j * j + i_cubed
        mul     j_cubed_sum, j, j                    @ wide insn
        mla     j_cubed_sum, j_cubed_sum, j, i_cubed @ wide insn
        @ Compare to the candidate
        cmp     j_cubed_sum, candidate
        bne     .Lno_match
.Lmatch:
        @ If it is the same, decrement matches_left
        subs    matches_left, #1
        @ Exit if we found all of the matches
        bne     .Lexit
.Lno_match:
        @ Decrement j and loop while non-zero.
        subs    j, #1
        bhi     .Lj_loop
.Lnext_i:
        @ Decrement i, and loop if it is not zero
        subs    i, #1
        bne     .Li_loop
.Lnext_candidate:
        @ Next candidate.
        adds    candidate, #1
        b       .Lcandidate_loop
.Lexit:
        movs    r0, candidate
        pop     {r4-r6, pc}

Explanation
C function signature:
uint32_t taxi(uint32_t n);

Has a wonderful O(n^3) complexity combined with billions of redundant iterations thanks to it looping backwards, but it works for n == 1 and n == 2 in reasonable time on hardware. It doesn't properly calculate n == 3 because of integer overflow.
It is a very naïve triple nested loop that is incredibly inefficient.
Goes through every candidate, then tests every i for i <= candidate, then tests every j for j <= i, each going backwards. It calculates cubes live, and is horrendously redundant and inefficient....but it is small and that is what counts.
Equivalent C:
uint32_t taxi(uint32_t n)
{
    for (uint32_t candidate = 1; ; candidate++) {
        uint32_t matches_left = n;
        for (uint32_t i = candidate; i != 0; --i) {
            uint32_t i_cubed = i * i * i;
            for (uint32_t j = i; j != 0; --j) {
                uint32_t j_cubed_sum = j * j * j + i_cubed;
                if (j_cubed_sum == candidate) {
                    --matches_left;
                    if (matches_left == 0) {
                        return candidate;
                    }
               }
          }
    }
}

Overflow-safe version
Here is a much faster one (but still slow) at 50 bytes which does not overflow before n == 3:
b570 2101 0004 2201 fb02 f502 4355 0013
fb03 f603 fb06 5603 428e d101 3c01 d006
3b01 d8f5 3201 428d d3ee 3101 e7ea 0008
bd70

        .text
        .arch armv6t2
        .thumb
        .globl taxi_safe
        .thumb_func
taxi_safe:
        @ Nickname some registers for clarity
        n .req r0
        candidate .req r1
        i .req r2
        j .req r3
        matches_left .req r4
        i_cubed .req r5
        j_cubed_sum .req r6

        push    {r4-r6, lr}
        @ Start with a candidate of 1 (even though it's impossible)
        movs    candidate, #1
.Lcandidate_loop:
        @ reset match counter
        movs    matches_left, n
        @ start checking cubes
        @ This version loops forwards from 1 and short circuits logically.
        @ It can correctly calculate n == 3.
        @ for (i = 1; i * i * i < candidate; i++) but the check is after the loop
        movs    i, #1
.Li_loop:
        @ i_cubed = i * i * i
        mul     i_cubed, i, i                        @ wide insn
        muls    i_cubed, i
        @ for (j = i; --j;)
        movs    j, i
.Lj_loop:
        @ j_cubed_sum = j * j * j + i_cubed
        mul     j_cubed_sum, j, j                    @ wide insn
        mla     j_cubed_sum, j_cubed_sum, j, i_cubed @ wide insn
        @ Compare to the candidate
        cmp     j_cubed_sum, candidate
        bne     .Lno_match
.Lmatch:
        @ If it is the same, decrement matches_left
        subs    matches_left, #1
        @ Exit if we found all of the matches
        bne     .Lexit
.Lno_match:
        @ Decrement j and loop while non-zero.
        subs    j, #1
        bhi     .Lj_loop
.Lnext_i:
        @ Increment i, and loop if i_cubed is less than candidate.
        adds    i, #1
        cmp     i_cubed, candidate
        blo     .Li_loop
.Lnext_candidate:
        @ Next candidate.
        adds    candidate, #1
        b       .Lcandidate_loop
.Lexit:
        movs    r0, candidate
        pop     {r4-r6, pc}

This one is significantly faster, and does not overflow before n == 3.
Instead of looping i backwards from candidate, we loop forwards from 1, and also short circuit when i * i * i >= candidate, although we do run the inner loop with this condition first so it is still very redundant.

source: Stack Exchange

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

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

sort: votes


text:
Is it a lipogram?
A lipogram is a block of words that omits a particular symbol. Right now, I am avoiding our fifth symbol of 26 that commonly show up. You should know by now what I am omitting. If not, look up "lipogram" and you will know.
Your Task
With a char, a blank, and a following string (blanks may show up in this; with only ASCII 32-126 chars) in input, output falsy if this char is in input string, truthy if not. This char that you must look for will always fit in two spans: "A" to "Z" or "a" to "z" (ASCII 65-90, 97-122). Do not distinguish capitals and non-capitals. Also, don't worry about blanks or punctuation symbols. Both programs and functions satisfy. Also, you may split input char and string into two args for programs or functions, and string as first arg is okay.
Illustrations
Truthy
e This is a lipogram.
a You need to consider other letters too.
E Capitals also count.

Falsy
e This sentence is not a lipogram (for e).
t This particular letter is surprisingly hard.
A You don't need to care about any non-alphabetic symbols.

Non-lipogrammed version
A lipogram is a series of words that leaves out a letter. I left out the letter "e" above.
Your task is to take a character and a string (which may include spaces) as input, separated by a space or newline, and output falsy if the character is in the string, and truthy otherwise. You may assume the string is composed solely of printable ASCII characters (char codes 32-126). The character will always be in the English alphabet, and there is no difference between lowercase and uppercase. The character will not be a space or symbol. You may write a program or a function. For either, you may take the character and string as separate arguments, and the string may come first.

For full programs may I take input as separate lines?

@muddyfish: Yes.

... and string as first arg is ok.

@edc65: Oh, I like that better.

You should try "and a string as your first arg is okay." or a similar configuration.

Also, I think a source-restriction challenge is in sight...

C, 42 bytes
#define f(c,s)!strchr(s,c)&!strchr(s,c^32)

Codegolfing in C, Ubercodegolfing.

Javascript ES6 34 26 23 Bytes
x=>!/^(.).*\1/i.test(x)

shaved 8 bytes thanks @MartinBüttner

Wow, I didn't know that /i affected \1!

05AB1E, 7 6 4 3 bytes
Code:
l`-

Explanation:
l     # Convert both elements to lowercase
 `    # Flatten the array
  -   # Loop over the second line of text and substract each char from the first character
        For example: "abcde""ba"- would result in "cde"

Try it online!
Truthy is when the current letter is outputted. Falsy is when nothing is outputted.

So - effectively does a complement operation?

@2012rcampion Yes, that is correct. But only when both values are not integers.

TeaScript, 5 3 bytes
AµN

Aha \o/! I forgot about implicit input! TeaScript will automatically insert x. (the input) at the beginning. I can then check if it has the other input (in variable µ) and so a NOT (N). I guess TeaScript's best advantage here is its implicit input
Try it online
Explanation
  A µ  N
x.A(y).N  // At compile time

x.A // input, has...
(y) // second input
N   // Logical NOT

Wow. Much built-in. That reminds me, Japt has this same built-in... cuts another two bytes off :)

Japt, 12 6 4 bytes
!VoU

Test it online!
@Downgoat's TeaScript answer reminded me that Japt has exactly the same built-in, cutting off a final two bytes.
How it works
       // Implicit: U = input char, V = input string
VoU    // Keep only the chars in V that are equal to U, ignoring case.
!      // Take logical NOT. Returns true if no matches were found, false otherwise.

@CᴏɴᴏʀO'Bʀɪᴇɴ Thanks to a built-in I had forgotten about, it's now even shorter :)

um wait no that's too short

Bash, 16 11 bytes
grep -iv $1

-i is the case-insensitive flag, -v inverts (checks for a non-match).
Character must be provided as a command line argument, and the test string on STDIN.
Reduced by 5 bytes with @DigitalTrauma's help!
Sample runs:
llama@llama:~$ echo 'This is a lipogram' | ./lipogram.sh e
This is a lipogram.
llama@llama:~$ echo 'This sentence is not a lipogram (for e).' | ./lipogram.sh e

Why not read the sentence from STDIN? grep -iv $1.  I don't see anything wrong with mixing STDIN and command-line args as input methods - I done it before - but perhaps there is a meta precedent I have missed...

@DigitalTrauma I considered that, but figured it'd be a bit sketchy. Perhaps a topic to be discussed on meta.

Programs may combine two or more input methods

Good find @Dennis!

Can we get any more ^D users to comment on this answer?  @Downgoat - are you there? ;-)

@DigitalTrauma the EOT control char or the letter D? :P

JavaScript (ES6), 29 bytes
(c,s)=>!RegExp(c,'i').test(s)

You can curry the answer as c=>s=>!RegExp(c,"i").test(s), saving a byte.

c=>s=>!s.match(c,'i') is 21. :)

@ETHproductions match only takes one argument. The second argument logs a console warning in Firefox 39 or later, and won't work in Firefox 47 at all.

@Neil I'm using Firefox 44, and it seems to work perfectly fine.

@ETHproductions Sure, but I have no reason to believe it works in other browsers, and it will also stop working in Firefox soon.

CJam, 6 byte
lel(&!

Try it online! lel
Explanation
l  e# Read a line of input.
el e# Convert to lower case.
(  e# Pull off the first character.
&  e# Set intersection with the rest of the input.
!  e# Logical NOT.

Python 3, 36
Having to ignore case is surprisingly expensive.
lambda a,b:a.lower()not in b.lower()

Takes the arguments as (char, string)

Perl, 11 + 1 = 12 bytes
$_=lc!~lc<>

Requires the -p switch and takes input as $string\n$letter
$ perl -pe'$_=lc!~lc<>' <<< $'this is a lipogram\ne'
1

How it works:
            # -p auto reads input into $_ and auto prints at the end
   lc       # lowercase $_
     !~     # Check against regex
       lc<> # Read next line and lowercase it. '=~' will expect the rValue to be
            # a regex and therefore the result from 'lc<>' will be treated as such
$_=         # Assign result ('1' or '') to $_ which will be printed

You should specify your shell. For me, bash on Ubuntu, this prints 1 no matter the input, following the template you give. (I don't know why, but, then, I'm unfamiliar with <<<.) (And using normal STDIN (no <<<), I get 1 unless the letter is the last character in the string, because you don't chomp the letter.)

@msh210 You can use printf "this is a lipogram\ne\n" | perl -pe'$_=lc!~lc<>' instead. <<<  is bash syntax.

@msh210 <<< is just another way to pass stdin.

Pyth, 8 7 bytes
-rz0rw0

Explanation
 rw0    -  input().lower()
-       - ^ - V
    rw0 -  input().lower()

Thanks @FryAmTheEggman for telling me I can use - instead of !}
Try it here

Julia 0.3, 22 20 bytes
c%s=c&95∉[s...]&95

uppercase is a long word.
How it works
c%s=c&95∉[s...]&95

c%s=                Redefine the binary operator % so it takes a character c and
                    a string s and...
     c&95                Compute lo bitwise AND of c and 95.
                         This casts the character c to uppercase.
          [s...]         Yield the list of the characters of the string s.
                &95      Compute lo bitwise AND of each chararacter and 95.
                         This casts the characters of s to uppercase.
         ∉               Return a Boolean, signaling non-membership.

PowerShell, 36 32 30 29 25 bytes
param($a,$b)$b-notmatch$a

Uses the -notmatch operator, and simply outputs True or False.

Seriously, 6 bytes
,ù,ùíu

Try it online!
Takes input as 'string'\n'char'
Explanation:
,ù,ùíu
,ù      get string (lowercase)
  ,ù    get char (lowercase)
    íu  1-based index (0 if not found)

Wouldn't something like ,ù,ùìuY work? (That's supposed to be the I that does indexOf but I don't remember which one does that)

Java, 63 bytes.
boolean f(String s,char c){return!s.matches("(?i:.*"+c+".*)");}

You could also write a lambda expression (s,c)->!s.matches("(?i:.*"+c+".*)") which is shorter

It wouldn't be a proper method though, you have to put String and char somewhere.

O, 8 bytes
{_.@_-=}

An anonymous function that takes a character and a string.
Try it online.
Explanation
{_.@_-=}

{      }
 _        Lowercase string
  .       Duplicate
   @      Rotate stack
    _     Lowercase character
     -    Remove all instances of the character
      =   Compare to original

Why does this need to be a function? Why not just have it be a program?

@phase I couldn't figure out what char was split. At any rate, I'm pretty sure it's shorter as a function anyways.

MATL, 5 bytes
kikm~

Try it online!
k        % take first input (letter) implicitly. Convert to lowercase
ik       % take second input (text). Convert to lowercase
m        % ismember function
~        % negate

Pyke, 7 bytes
Dl3+R{!

Explanation:
D       -     eval_or_not(input()).lower()
 l3     -    ^.swapcase()
   +    -   ^+^
    R   -  rotate 2
     {  -  ^ in ^
      ! - not ^

Retina, 11
iA`^(.).*\1

I'm not sure what counts as truthy / falsy in Retina, this will echo the line if it is a lipogram for the given character, and it will return the empty string if it isn't.
This will also work for multiline input.
Try it online!

An empty string is falsy, so that counts.

Minkolang 0.15, 10 bytes
$or7Z0Z,N.

Try it here.
Explanation
$o            Read in whole input as characters
  r           Reverse stack
   7Z         Lowercase everything
     0Z       Pop top of stack (a) and count how many 'a's are in the stack
       ,      'not' the top of stack
        N.    Output as number and stop.

Jelly, 8 bytes
ḢO^O&95P

Try it online!
How it works
ḢO^O&95P  Main link. Input: S (string)

Ḣ         Pop the first character of S.
 O        Ordinal; compute its code point.
  ^O      XOR it with the code points of the remaining characters.
    &95   AND each result with 95.
       P  Take the product of the results.

Wait, jelly isn't winning? There must be a way to golf it down further!

Not when strings are involved...

This must be rectified.

Rust, 75 bytes
|c:char,s:&str|!s.to_lowercase().contains(c.to_lowercase().next().unwrap())

Biggest score means I win, right? >_<
Try it here.

Python, 34 bytes
lambda c,s:c not in s+s.swapcase()

Checks for character c being in string s, ignoring case by appending a case-swapped copy of s to s. The negation is done with not, which looks lengthy but I don't see better. This is same length:
lambda c,s:(c in s+s.swapcase())<1

You can't omit the parens or else Python will interpet the expression as a chained three-value inequality of form _ in _ < _.
Python 3.5 should allow 33 bytes via set conversions, though I can't test it now.
lambda c,s:{*c}-{*s+s.swapcase()}

JavaScript ES6, 41 40 bytes
x=>!~x.slice(2).search(RegExp(x[0],"i"))

Takes the entire string as an argument. I cannot save bytes by accepting two different arguments because then my answer would melt into the other ES6 answer :(

I win this time, ES6. ;) Your anonymous function syntax is no match for my not in.

@MorganThrapp Gahh, foiled again!

that's ok I got this,
You move @MorganThrapp.

CJam, 10 bytes
{el\ele=!}

An anonymous function (block) that takes a character (not a string!) and a string.
Try it online.
Explanation
{el\ele=!}

{        }
 el\el      lowercase both args
      e=    count occurrences of the character
        !   logical not

R, 26 bytes
 function(x,y)!grepl(y,x,T)

x is the string, y is the letter, the T in the call to grepl makes it case insensitive.

Jolf, 6 7 bytes
So. Many. Sixes. SMS? Well, try it here nonetheless. Replace ⌂ with \x7f.
⌂ MiI'i
⌂_M      match with flags
   i     the input
    I    with another input
     'i  using i as a flag

Vyxal, 6 bytes
ɽfhO2<

Try it Online!
Accepts one line as input, formatted like the test cases.
How it works:
ɽf          # convert input to lowercase and turn into list
  hO        # count the number of times the first item in the list occurs
     2<     # is it less than 2 (should only occur once as the first character)

I managed to get this down to 3 bytes for you: Try it Online!. It outputs a single letter if it is a lipogram and an empty string if it isn't.

thanks! are single letters truthy values?

Any non-empty string is a truthy value. Also, 05ab1e uses the same output format as the 3 byter.

Ruby, 17 bytes
->c,s{/#{c}/i!~s}

->c,s{  # lambda with two arguments
/#{c}/  # turn the input character into a regexp w/ interpolation
i       # case insensitive
!~      # does not match
s       # input string
}

Mathematica, 33 32 bytes
StringFreeQ[##,IgnoreCase->1>0]&

I love it when ## can be used.
Input is string, then char.
Or, a case sensitive version: (11 bytes:)
StringFreeQ

Yep, just a builtin.

Batch, 53 bytes
@set s=%2
@call set t=%%s:%1=%%
@if %s%==%t% echo 1

Accepts input as two command-line arguments. (Quote the second argument if necessary.) Outputs 1 on success, nothing if the first argument is (insensitively) found in the second.

Haskell, 45 bytes
import Data.Char
t=toLower
(.map t).notElem.t

Usage example: ( (.map t).notElem.t ) 'a' "You need to consider other letters too" -> True.
It's a pointfree version of f c s = notElem (toLower c) (map toLower s), i.e. convert letter and string to lowercase and see if the letter is not in the string.

Java 8 lambda, 48 46 bytes
Thanks to @Geobits for pointing out my stupidity and saving me 2 bytes!
(String i,char o)->i.split("(?i)"+o).length&lt2
Splits the string if the sought char is found. Returns true if it is contained, false otherwise.

Why not (String i,char o)->!i.contains(o) with Java 8?

@DenkerAffe Didn't work insensitively. Fixed now, in lambda form.

Fig, \$2\log_{256}(96)\approx\$ 1.646 bytes
as

Try it online!
as # Returns 0 for truthy and "true" (?!) for falsey. Takes a list of chars as input
 s # String equals ignore case (vectorising)
a  # Any truthy?

Lua, 47 Bytes
Simply use string.find() and a ternary to know if there's a prohibited character in the string.
Takes input via command-line: lua golf.lua 'e' "This is a Lipogram."
Edit: Saved 20 Bytes thanks to @Oleg V. Volkov.
print(not arg[2]:lower():find(arg[1]:lower()))

There's no need to waste bytes asigning to c, arg[2] could use a lower too, and right now it ouputs bad value 0, which is true in Lua. print(not arg[2]:lower():find(arg[1]:lower()))

@OlegV.Volkov Oh, thanks. Don't know why I did it this way... must have been tired...

SpecBAS - 36 bytes
1 INPUT a$,b$: ?POS(UP$ a$,UP$ b$)=0

Returns 1 (True) if letter is NOT found, 0 (False) if it is.
Converting to uppercase with UP$ save once character vs LOW$

><> , 42 bytes
i:"a"(?\:i:0(?\= ?\70.
.18+" "/   ;n1/;n0/

Overview :
i:"a"(?\
.18+" "/

Grabs the first letter, adds space (32) to it if it's not lowercase

:i:0(?\
   ;n1/

Grabs the following letters from the input. It compares them to 0 in order to know if it has reached the end of the input, in
  which case i returns -1. In this case it will output 1 and stop.

= ?\70.
;n0/

Compare the current letter to the first one. If they're equal, output
  0 and stop. Otherwise, jump back to the beginning of the loop.

You can give it a try on the online interpreter, it nicely illustrates the program flow.

Hoon, 61 56 bytes
|*
{a/* b/*}
(lien (trip (cuss b)) (cury test (cuss a)))

There are a couple reasons why this is so bad. Unfortunately, Hoon's uppercase/lowercase function is tape -> cord, so another ++trip call is needed from the result of cuss to turn it back into a list of characters. It also doesn't have a function to test if the list contains a value, only if a function returned yes on any entry.
Hoon has two syntaxs: wide-form and tall-form. Wide-form uses ()'s for grouping such as ?:(a b c), while tall-form uses whitespace (either two spaces or a newline) for seperation of twigs. Since newlines count as one byte, using tall-form after runes is smaller although it looks very silly and no one would write it like that.
This entry also abuses Hoon's generic system, wet gates. The |* rune is like |=, which creates a "function" except that it replaces the type signature with the type of the sample and typedchecks at the callsite instead of definition. Since |* and |= are the exact same length, but you can omit the type info for the function args, it's smaller to just let the caller provide the type information instead of having |=  {a/tape b/tape}.
To call it, enter %+ in the Urbit :dojo, then this snippet, then "A"  "You don't need to care about any non-alphabetic symbols." (two spaces between those strings!). This is simply a Hoon two-argument function call.

Befunge 27x2 = 54 bytes
 >:~:1+#v_1.@>\:88*`#v_$$
#^_0.@  >\: #^_$~%:0 >84*%-

Try It Online
A shorter version that doesn't account for non-alpha characters
 >:~:1+#v_1.@_~$84*%
#^_0.@  >\:!#^_\84*%-

GML, 66 bytes
return string_pos(string_lower(argument0),string_lower(argument1))

How does this take input?

It's a function.

In GML all scripts receive arguments in the form of argument0, argument1, etc. or as an argument[] array. They can return a value with return.

Scala, 50 bytes
def f(s:String,c:Char)= !s.matches(s"(?i:.*$c.*)")

(Mostly derived from the Java answer)

Groovy, 58 bytes
print args[1].toLowerCase().indexOf(args[0].toLowerCase())

Run with:
groovy filename.groovy *char* *string*

Oracle SQL 11.2, 68 bytes
SELECT TRANSLATE(UPPER(:2),UPPER(:1)||UPPER(:2),UPPER(:1))FROM DUAL;

:1 is the char
:2 is the string
Return NULL/empty string as truthy, everything else is falsy.
It translates every character of the string :2 to nothing, which removes them, except for the :1 char.

DUP, 33 bytes
[`32~&a:0[\1-$;$][32~&a;=@|]#%%~]

Try it here.
Anonymous lambda that takes input from both argument and STDIN and leaves result on stack. Usage:
0"asdf"[`32~&a:0[\1-$;$][32~&a;=@|]#%%~]!

Explanation
[                                ] {lambda}
 `                                 {get STDIN char}
  32~&                             {uppercase (charcode representation)}
      a:                           {store to a}
        0                          {push 0 to stack as bool}
         [      ][          ]#     {while loop}
          \1-$;$                   {reduce from last string char:}
                  32~&               {uppercase}
                      a;=            {get a==[uppercase char]}
                          @|         {XOR result with bool}
                              %%~  {drop twice, negate TOS (bool)}

C++14, 53 bytes
Based on Josh's answer
As unnamed lambda, assumes s to be std::string and c to be char:
[](auto s,auto c){return s.find(c)+s.find(c^32)==-2;}

Also assumes the length of the strings is below 2^31. If that may be the case, use the safer 58 byte variant:
[](auto s,auto c){return s.find(c)==-1&&s.find(c^32)==-1;}

Usage:
auto f =
  [](auto s,auto c){return s.find(c)+s.find(c^32)==-2;}
;

int main() {
  std::string a = "abcdfg";
  std::cout << f(a,'e') << std::endl;
  std::cout << f(a,'E') << std::endl;
  std::cout << f(a,'a') << std::endl;
  std::cout << f(a,'A') << std::endl;
}

C#, 52 51 bytes
(C,I)=>{return!I.ToLower().Contains(C.ToLower());};

If I could find a way to get rid of ToLower(), I'd save 16 bytes.
One of those cases where I can get rid of the space after return, yay.

C|32 makes ToUpper(), that way you could check I.ToUpper().Contains(C|32)

Yeah I tried that route, but I'd have to cast to char and then convert that to a string with "" for Contains, which ends up being longer than just ToLower twice.

J, 19 bytes
1=&#[:<;._1 tolower

Try it online!

Go, 77 bytes, using regexp
import."regexp"
func k(c,s string)bool{b,_:=MatchString("(?i)"+c,s)
return!b}

Attempt This Online!
Go, 78 bytes, using strings
import."strings"
func f(c,s string)bool{L:=ToLower
return!Contains(L(s),L(c))}

Attempt This Online!

Thunno 2, 3 bytes
LẸ-

Try it online!
Port of Adnan's 05AB1E answer.
Explanation
LẸ-  # Implicit input
L    # Lowercase
 Ẹ   # Dump
  -  # Subtract
     # Implicit output

Java, 51 bytes
return(!s.toLowerCase().contains(c.toLowerCase()));

Uses s as input and c as char, but c must be of type String.

This tries to take input from variables, which isn't allowed.

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/


text:
Reading a timeline
Inspired by Draw a timeline.
Given a timeline of events, output the date for each event.
A timeline will be given in the form
    2000
--AF-C-------E--D---B--

Where the first line shows a known point in time. The known year is always the character below the first digit of the known year
You may assume:

On the timeline itself, each character represents one year.
There will always be at least one event
The events don't have to be in order
You may assume every character in the range between A and the furthest character is present
There will be at most 26 events
The known point will not have any padding to the right
There can be negative numbers in both the known point and the output
You will not have to handle numbers bigger than 2^32
You will not have to handle ranges bigger than 2^8
You can take input as lowercase letters instead of uppercase

You should write a program that takes a timeline in this form and outputs the key dates in order (A, B, C, D...)
You may output in a convenient form but you must take input in the format given.
Test cases:
    2000
--AF-C-------E--D---B--
[1998, 2016, 2001, 2012, 2009, 1999]

     10
--C-AB--D
[9, 10, 7, 13]

     0
--ABCDEFG--
[-3, -2, -1, 0, 1, 2, 3]

          5
--ABCDEFG--
[-3, -2, -1, 0, 1, 2, 3]

... input in the format given. That is? A single string with a newline? or 2 strings?

2 strings or a string with a newline

Pyth, 16 bytes
Takes input as lowercase letters instead of uppercase.
VS@GJw+-sz/zdxJN

05AB1E, 19 18 bytes
Code:
ð¢>UágF²N>.bkX-¹+,

Explanation:
ð¢                   # Count the number of spaces before the year starts
  >                  # Increment by 1
   U                 # Pop and store this into X
    á                # Keep the alphabetic characters of the second input
     g               # Take the length
      F              # For N in range(0, length), do...
       ²             #   Take the second input
        N>           #   Push N and increment by 1
          .b         #   Converts 1 to A, 2 to B, etc.
            k        #   Find the index of that letter in the second input
             X       #   Push X
              -      #   index - X
               ¹     #   Get the first input, which contains the year
                +    #   Add to the difference of the index
                 ,   #   Pop and output the sum

Try it online!
Uses CP-1252 encoding.

JavaScript (ES6), 72
(a,b,r=[])=>[...b].map((x,i)=>r[parseInt(x,36)-10]=+a+i-a.search`\\d`)&&r

Test

f=(a,b,r=[])=>[...b].map((x,i)=>r[parseInt(x,36)-10]=+a+i-a.search`\\d`)&&r

console.log=x=>O.textContent+=x+'\n'

;[['    2000','--AF-C-------E--D---B--'],
['     10','--C-AB--D'],
['     0','--ABCDEFG--'],
['          5','--ABCDEFG--']]
.forEach(t=>{
  var a=t[0],b=t[1],r=f(a,b)
  console.log(a+'\n'+b+'\n'+r+'\n')
})

Bash + coreutils, 68
Line 1 is input as a quoted command-line option and line 2 is input from STDIN:
s="${1//[0-9]}"
fold -1|nl -v$[$1-${#s}]|sort -k2|sed '/-$/d;s/.$//'

Perl, 58 + 1 = 59 bytes
/\d/;$b=<>;for$c(A..Z){($z=index$b,$c)>-1&&say$_+$z-$-[0]}

Breakdown:
/\d/;                    # Match first digit in input string, this will set $-[0]
$b=<>;                   # Read next line (--A--CB--...) into $b
for $c (A..Z){           # Iterate over A, B, C, ... Z
  ($z=index$b,$c) >-1 && # If the character is found inside $b
  say $_+$z-$-[0]        #   then print
}

Requires -n and the free -M5.010:
# Added line breaks for each test case
$ perl -nE'/\d/;$b=<>;for$c(A..Z){($z=index$b,$c)>-1&&say$_+$z-$-[0]}' tl
1998
2016
2001
2012
2009
1999

9
10
7
13

-3
-2
-1
0
1
2
3

-3
-2
-1
0
1
2
3
$ cat tl
    2000
--AF-C-------E--D---B--
     10
--C-AB--D
     0
--ABCDEFG--
          5
--ABCDEFG--

Pyth, 22 bytes
V+r\AJeSKwJ+xKN-izT/zd

No I did not write this before I posted the challenge.
Explanation:
                       - autoassign z = input()
 +r\AJeSKwJ            -  create range of letters
        Kw             -      autoassign K = input()
      eS               -     sorted(K)[-1] (get the biggest character)
     J                 -    autoassign J = ^
  r\A                  -   range("A", ^)
 +        J            -  ^ + J
V                      - for N in ^: V
               -izT/zd - Get the number at the start
                izT    -   int(z, 10)
               -       -  ^-V
                   /zd -   z.count(" ")
           +           - V+^
            xKN        -  K.index(N)

Try it here

Python 3, 118
Man, today is the day of long Python answers.
def f(p,l):o=sum(x<'0'for x in p);e={x:i-o+int(p[o:])for i,x in enumerate(l)if'@'<x};return list(map(e.get,sorted(e)))

Perl, 80 79 71 67 bytes
($a=<>)=~/\d/;$b=<>;say$a+$_-$-[0]for grep{$_+1}map{index$b,$_}A..Z

Thanks to @dev-null for 12 bytes!
($a=<>)=~/\d/;  # read first line of input, find position of first digit
                # (saved in the $- variable)
$b=<>;          # read the second line
                                           A..Z  # generate range 'A','B',...
                            map{index$b,$_}      # find index for each
                  grep{$_+1}                     # select only those != -1
              for                                # foreach of remaining...
say$a+$_-$-[0]                                   # calculate proper date

Seriously, 40 bytes
' ,c,;)l@;±)@-(x@;╗@Z`i3╤τ+@┐`MX╜ú∩S`└`M

Try it online!
Explanation to come later after further golfing.


text:
Adding up the digits and the digits reversed
Given a number > 0, output the sum with all digits (1 .. n) concatenated and reversed and add them up. For example, with n = 6:
The numbers 1 to 6 concatenated:
123456

Reversed:
654321

Adding them up together will result in: 777777. Another example is n = 11:
1 2 3 4 5 6 7 8 9 10 11 > 1234567891011

and
11 10 9 8 7 6 5 4 3 2 1 > 1110987654321

Adding them up together will result in 2345555545332. This is also known as A078262.
Shortest code wins!

Related.

Is there a bound to n, or do we have to support arbitrarily large integers?

I think the default is "bounded by max(256,yourlanguagesdefaultintegertypelimit)". But it should be specified.

@LegionMammal978 As high as your language supports.

Important test case: 10, which should give 23333333231.

05AB1E, 7 bytes
LDRJsJ+

Try it online.
Explanation
LDRJsJ+

L        range from 1 .. input
 D       duplicate
  R      reverse
   JsJ   convert both arrays to strings
      +  add (coerces both strings to ints)

I feel very confused by the design choice that lead to + on lists doing a nested addition, while for strings it converts to ints and then adds. But I guess it worked out here! :P

@FryAmTheEggman I'm going to remove nested addition though. It has never been useful since the moment I've implemented it...

Sheesh, I leave PPCG for two hours and you rename yourself Aqua Tart while I'm gone... Oh, the life of a PPCG user.

Jelly, 9 bytes
R,U$DF€ḌS

Is it me or do I see that code secretly stealing some U$D?

-3 bytes

CJam, 15 14 bytes
Thanks to Martin for shaving a byte!
ri,:)_W%si\si+

Try it online!

1 byte less if you flip the string instead of the numeric array: ri,:)s_W%i\i+

Sorry, I think my version doesn't work for 10

This code is secretly happy. :)

Pyth, 12 10 bytes
ssMjLk_BSQ

Thanks to @FryAmTheEggman for 2 bytes!
Q is the input, S turns it into [1, 2, ..., input()], _B bifurcates it over _ (reverse) to create [rng, rev(rng)], jLk maps it over join by k (which is the "empty string" variable), sM maps int over this resulting array, and s finally calculates the sum.

Python 3, 74
Saved 6 bytes thanks to DSM.
Nothing too exciting, join the ranges and then convert to ints and add them.
lambda x:sum(int(''.join(list(map(str,range(1,x+1)))[::i]))for i in(1,-1))

71 bytes

JavaScript (ES6), 70 67 64 bytes
a=>(z=[...Array(a)].map((b,c)=>c+1)).join``- -z.reverse().join``

Fixed to meet requirement, as old code was made under misunderstanding of the input.

@TimmyD Added an explanation.

@TimmyD OH! >_< My misunderstanding of the challenge is how... Yeah, I'll have to fix this.

@TimmyD Took me long enough to get back online. It's fixed now, and thanks for catching that.

As noted for another answer, this only works if the parameter a is between 1 and 12, that's really too little

@edc65 Per OP's comment, that's big enough.

Retina, 71

7 bytes saved thanks to @daavko.
3 bytes saved thanks to version 0.7.3 features

Because its blatantly the wrong tool for the job.
.+
$*a:$&$*
+`^(a+)a\b(.*)\b1(1+)$
$1 $& $3
 ?(\w)+ ?
$#1
\d+:?
$&$*c
c

Try it online.
Works for inputs up to 6, but the online interpreter times out after that.

You can shorten it to 74 by removing the last line and changing (c)+ to c.

@daavko yes, of course, thanks!

Also, $&$*c -> $*c and \d+:? -> \d+ and it's 70. And for some reason it keeps working...

JavaScript (ES6), 67 66 bytes
n=>(a=[...Array(n+1).keys()].slice(1)).join``- -a.reverse().join``

Yes, that's a space. Ugh. At least @Downgoat helped me save a byte.

You can remove the first + and make the + + -> - - to save a byte

n=>(a=[...Array(n)].map(_=>n--)).join- -a.reverse().join

Note: using simple js arithmetic this is limited to values 1 .. 12

Jolf, 9 bytes
Try it here! Replace ► with \x10.
+P►γzjP_γ
    zj    range 1...j
   γ      γ = ^
  ►        ^ .join("")
 P         as a number
+     P_γ  and γ reversed

I may be able to golf it by moving around the type casting.

You beat pyth and doorknob!

@Cyoce so I did O_O

Vyxal s, 5 bytes
ɾḂWvṅ

Try it Online!
ɾ         range: [1 .. x]
 Ḃ        pop x, push x, reversed(x) [bifurcate]
  W       wrap the stack
   v      for each
    ṅ     join on ""

s (flag)  sum

-2 bytes thanks to Razetime

-1: Try it Online!

@Razetime oh so there is a shorter way to do that. thanks

s flag should reduce another byte.

@Razetime guess it's too late to turn back from the flags now, isn't it

Seriously, 12 bytes
,R;Rεj≈@εj≈+

Try it online!
Explanation:
,R;Rεj≈@εj≈+
,R;           push two copies of range(1, input()+1)
   R          reverse one copy
    εj≈@εj≈   concatenate both and cast both to ints
           +  add

PowerShell, 35 bytes
param($a)+-join(1..$a)+-join($a..1)

Converts the input to ranges with .., then -joins them together, and adds 'em up.
Will work for input numbers up to 138, while 139 will give Infinity, and 140 and above will barf out an awesomely verbose casting error:
Cannot convert value "12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413
5136137138139140" to type "System.Int32". Error: "Value was either too large or too small for an Int32."

JavaScript (ES6), 99
This adds digit by digit, so it can handle numbers well above the 53 bits of precision of javascript
n=>eval("for(a=b=c=r='';n;a+=n--)b=n+b;for(i=a.length;i--;r=c%10+r)c=(c>9)-(-a[i]-b[i]);c>9?1+r:r")

Test

f=n=>eval("for(a=b=c=r='';n;a+=n--)b=n+b;for(i=a.length;i--;r=c%10+r)c=(c>9)-(-a[i]-b[i]);c>9?1+r:r")

// Less golfed
U=n=>{
  for(a=b=c=r=''; n; --n)
      b=n+b, a+=n;
  for(i=a.length; i--; r = c%10+r)
      c=(c>9)-(-a[i]-b[i]);
  return c>9? 1+r : r;
}

function test() {
  var n=+I.value
  R.textContent=f(n)
}

test()
N: <input id=I value=11 oninput="test()"> ->

Doesn't seem to work for 9. Also, why not initialise c with the other variables?

You have my upvote.

MATL, 13 bytes
:tP2:"wVXvU]+

EDIT (May 20, 2016) The code in the link uses Xz instead of Xv, owing to recent changes in the language.
Try it online!
:                % range [1,2,...,n], where n is input
 tP              % duplicate and flip
   2:"     ]     % do this twice
      w          % swap
       V         % convert array of numbers to string with numbers and spaces
        Xv       % remove spaces
          U      % convert to number
            +    % add the two numbers

Doesn't work for 11 or 10. (Hint: reverse range before converting to string.)

@ӍѲꝆΛҐӍΛПҒЦꝆ Thanks! Corrected

Great! Have an upvote.

Pyth - 8 bytes
siRT_BSQ

Try it online here.

I think this doesn't work for 10 or 11

Brachylog, 24 bytes
:1fLrcC,Lc+C=.,{,.:1re?}

05AB1E, 5 bytes
LJDR+

Explanation:
L     # Pushes an array containing 1 .. [implicit] input
 J    # Join the array to a string (eg. [1, 2, 3] -> 123)
  D   # Duplicate the array
   R  # Reverse the duplicate
    + # Add them together

Try it online!

Late comment, but doesn't work for 10 - you are reversing the string after you join, instead of before.

R, 34 60 64 bytes
f=pryr::f;g=f(as.numeric(paste(x,collapse='')));f(g(1:n)+g(n:1))

Assumes pryr package is installed. this gives f as a shorthand for creating functions.
Edit added 26 bytes but returns a function that works, not something entirely wrong.
Edit added another 4 bytes to handle cases above n=10 where strtoi (previously used) was returning NA

Bash + coreutils, 39
eval echo {1..$1} + {$1..1}|tr -d \ |bc

Or:
bc<<<`eval printf %s {1..$1} + {$1..1}`

Ideone.

Perl 6, 25 bytes
{([~] @_=1..$^n)+[R~] @_}

{
  (
    [~]           # reduce with the string concatenation infix op:
    @_ = 1 .. $^n # the range 1 to input ( also stored in @_ )
  )
  +               # add that to
  [R~] @_         # @_ reduced in reverse
}

Usage:
for 6, 11, 12 -> $n {
  say {([~] @_=1..$^n)+[R~] @_}( $n )
}

777777
2345555545332
244567776755433

I think you can do with $n instead of $^n

@dev-null Not if I want it to be an input to the block. the -> $n { is a different one to $^n.

Dyalog APL, 17 bytes
+/⍎¨∊¨⍕¨¨x(⌽x←⍳⎕)

⎕ prompt for input
⍳' enumerate until input
x← store list in x
⌽ reverse x
x(…) prepend reversed list with original list
⍕¨¨ convert each number of each list into character string
∊¨ make each list of character strings into single character strings
⍎¨ convert each character string into a number
+/ sum the two numbers.

Lua, 53 Bytes
This program takes n as a command-line argument.
s=""r=s for i=1,arg[1]do r,s=i..r,s..i end print(s+r)

I assumed that outputing a number with a decimal part of 0 was okay (in the form 777777.0 because this is the default way to output a number in lua (there's no distinction between integer and float)

Its not the string itself that is reversed, but the digits. Your code fails on n >= 10.

@Moop Corrected at the price of 1 byte ^^'. Thanks for the comment ^^'

You can save 3 more using ... instead of arg[1] nice work on the reverse concat for r, didn't think of that in my answer. +1

@Moop I saw your post, nice use of it, I didn't even know you could use ... like that! I'll keep it this way for the moment, because I can't use anything else than the online compiler and it can't handle that(I'd like to test it and play with it a little bit before putting it in a answer :))

Lua, 57
a=''b=''for i=1,...do a=a..i b=b.. ...-i+1 end return a+b

Perl 5, 37 bytes
25 bytes, plus 1 for -p and 11 for -MList::Gen
$_=<[.]1..$_>+<[R.]1..$_>

Previous solution, 40 bytes: 39, plus one for -p
@a=reverse@_=1..$_;$"=$\;$_="@a"+"@_"

Perl, 36 bytes
Includes +1 for -p
Run with on STDIN
perl -p reverse.pl <<< 6

reverse.pl
$_=eval join"",map{abs||"+"}-$_..$_

Haskell, 57 56 48 bytes
This could probably be golfed a bit more, but here it goes:
f x=read y+(read.reverse$y)where y=[1..x]>>=show

Edit: shaved off a space before the where.

Factor, 59 bytes
[ [1,b] dup reverse [ [ present ] map concat dec> ] bi@ + ]

Try it online!

[1,b] Create a range from 1 to the input, inclusive.
dup reverse Make a copy and reverse it.
[ [ present ] map concat dec> ] bi@ Convert them both to numbers of concatenated numbers.
+ Add.

Python 3, 79 bytes
a=''.join([str(i+1) for i in range(int(input()))])
print(int(a)+(int(a[::-1])))

Try it online!

Thunno 2 s, 4 bytes
RJNḲ

Try it online!
Explanation
RJNḲ  # Implicit input
R     # Push [1..input]
 J    # Join into a string
  N   # Convert to integer
   Ḳ  # Duplicate and reverse
      # Sum the stack
      # Implicit output

Mathematica, 64 bytes
Plus@@FromDigits/@#&[""<>ToString/@#&/@{#,Reverse@#}&[Range@#]]&

Retina, 80 bytes (ISO 8859-1 encoding)
'+
$0¶$0
+`^(('+)')
$2 $1
+`('('+))$
$1 $2
(')+( |$)?
$#1
(\d+)¶(\d+)
$1$*'$2$*'

IO is in unary with ' as the counting character. In theory supports any integer you throw at it, in practice...online interpreter refuses to process anything larger than 6 (unary '''''').
Try it online!
Try it online! (decimal IO - 91 bytes)

, 12 chars / 15 bytes
⨭⟮⩤⁽1ï⟯⨝,Ⅰᴚ⨝

Try it here (Firefox only).
Meh.
Explanation
Takes a range [1,input], joins it; takes that same range, reverses it, then joins it; the sum of both ranges is the result.

Ruby, 40 characters
->n{eval (l=[*1..n])*''+?++l.reverse*''}

Sample run:
irb(main):001:0> ->n{eval (l=[*1..n])*''+?++l.reverse*''}[11]
=> 2345555545332

irb(main):002:0> ->n{eval (l=[*1..n])*''+?++l.reverse*''}[6]
=> 777777

C#, 126 bytes
using System.Linq;a=>{var b=Enumerable.Range(1,a);return long.Parse(string.Concat(b))+long.Parse(string.Concat(b.Reverse()));}

Could possibly be golfed further. Not really sure.

Groovy, 42 39 characters
{[1..it,it..1]*.join()*.toLong().sum()}

Sample run:
groovy:000> ({[1..it,it..1]*.join()*.toLong().sum()})(11)
===> 2345555545332

groovy:000> ({[1..it,it..1]*.join()*.toLong().sum()})(6)
===> 777777

Groovy, 112 characters
def r(n){if(n==1){return n;};return n+''+r(n-1)};n=6;s=r(args[0].toLong());print s.toLong()+s.reverse().toLong()

run with:
groovy filename.groovy *input*

Perl 6, 25 bytes
Either one works
{([~] 1..$^n)+[R~] 1..$n}
{([~] 1..$^n)+[~] $n...1}

QBIC, 24 bytes, nc
:[a|B=B+!b$]_FB|?!A!+!B!

Explanation
:       Read command line argument as 'a'
        Generate the sequence 1 ... a
[a|     For b = 1 to a step 1
B=B+!b$ Add b cast to string to the end of B$ (starts out empty)
]       Ends the FOR loop
_FB|    Reverse (Flip) B$ and assign the result to A$
?       Show on screen
!A!+!B! A$ cast to num + B$ cast to num

Non-competing, the _F was implemented way after this challenge was posted.

Pushy, 10 bytes
RV@KjOjv+#

Try it online!
RV    \ Push the range to both stacks.
@Kj   \ Reverse and join the first stack
Oj    \ Join the second stack
v+    \ Sum the two resulting integers
#     \ Print result

Arturo, 31 bytes
$->n[+do join@n..1do join@1..n]

Try it!
$->n[          ; a function taking an argument n
    1..n       ; the range [1..n]
    @          ; reify to block of integers
    join       ; convert [1 2 3] to "123", for instance
    do         ; eval -- convert numeric string to integer
    n..1       ; the range [n..1]
    @          ; reify to block of integers
    join       ; convert [1 2 3] to "123", for instance
    do         ; eval -- convert numeric string to integer
    +          ; add
]              ; end function


text:
Sandpile integers
Challenge
You will be given a positive integer n as input.  Output should be a pyramid-like sandpile built on the rules specified below:

Each integer "falls" downward from the same initial starting point, like sand falling into a conal-shape.
Numbers greater than the number directly below it when it hits the sandpile will fall to the right, if able.
Numbers less than the number directly below it when it hits the sandpile will fall to the left, if able.
Numbers equal to the number directly below it when it hits the sandpile will stay in place.
Numbers are able to fall to the left/right if they can move down and to the left/right respectively.  That is, if there is already a number below and to the left/right, depending on the direction, the currently falling number does not move.
A number will continue to tumble down the sandpile until it cannot be moved into its next position, or hits the floor.

Notes
The initial comparison check only applies to the first encountered integer, not for each successive encounter as it tumbles down the sandpile.
Trailing spaces are okay but trailing new lines are not.
No leading spaces or new lines except where needed to preserve the structure of the sandpile.
You may write a full program or function.
You may assume input will only contain some combination [0-9].
This is code-golf, shortest code in bytes will be marked winner by the Ides of March
Examples
1
1

12345
35
124

54321
 13
245

555444333222111
    2
    2
    2
  135
 1345
13445

111222333444555
4
4
4
135
1235
12235

7313623030872935273465247457435345345350
    3
    3
    3
    3
    34
    355
    3644
   239475
  201277445
020373685575

555444333222111 is that a mistake that the third 4 will fall left to the first 4?

@dev-null numbers will continue to 'tumble', if you will, so long as they are able - remember, the greater/less/equal check only applies to the first encounter.

JavaScript (ES6), 260 208 bytes
s=>[...s].map(c=>a[g(n,(c>(l=a[n].slice(-1)))-(c<l))]+=c,n=s.length,a=Array(n+n).fill(''),g=(i,d)=>a[i].length>a[i+d].length?g(i+d,d):n)&&[...a[n]].map((_,i)=>a.map(c=>c?c[i]||' ':c).join``).reverse().join`\n`

Edit: Saved 25 bytes by realising that the first character isn't a special case. Saved 15 bytes by using an array of strings instead of an array of arrays of chars. Saved 12 bytes in miscellaneous fixes, including using a literal \n (not shown). That makes this whole 20% shorter! I wanted to get rid of reverse but that costs more than I can then save by replacing map with replace.
Ungolfed:
function sandpile(str) {
    var arr = new Array(str.length * 2); // max width of sandpile is approx. 2√n but this is close enough
    for (i = 0; i < arr.length; i++) arr[i] = '';
    for (i = 0; i < str.length; i++) {
        var digit = str[i];
        var pos = str.length; // start dropping here
        if (digit < str[pos][str[pos].length - 1]) {
            while (str[pos - 1].length < str[pos].length) pos--;
        } else if (digit > str[pos][str[pos].length - 1]) {
            while (str[pos + 1].length < str[pos].length) pos++;
        }
        str[pos] += digit; // drop the digit
    }
    var len = arr[str.length].length; // final height
    // remove the unused columns, and then pad the columns with spaces for the transpose
    for (i = 0; i < arr.length; ) {
        if (!arr[i]) arr.splice(i, 1);
        else arr[i++] += ' '.repeat(len);
    }
    ans = '';
    for (i = len; i-- > 0; ) {
        for (j = 0; j < arr.length; j++) ans += arr[j][i];
        ans += '\n';
    }
    return ans;
}


text:
Cause maximal disruption to a Straw Poll
Context
Straw Poll is a website that is meant for the creation of simple/informal polls.  Provided with a list of options, the user can select their choice(s), and the votes are tallied up.  There's two very important features of a Straw Poll:

It is possible to view the current results before voting
It is often possible to select multiple options, which is treated the same way as if you voted multiple times, one for each option.

The one thing that's more fun than making Straw Polls is messing with the results. There's two main types of disruption:

Simple disruption, in which you vote for all the options
Advanced disruption, in which you strategically pick which options to vote for in order to maximize the effect.

In this challenge, you will write a program for advanced disruption.
The Math
To simply things mathematically, we can say that the higher the entropy of the votes, the more disrupted a poll is.  This means that a poll where a single option has all the votes isn't disrupted at all, while a poll where every option has an equal number of votes is maximally disrupted (this being the ultimate goal).
The entropy of a list of numbers \$[x_1, x_2, \dots x_n]\$ is given by the following equation from Wikipedia. \$P(x_i)\$ is the probability of \$x_i\$, which is \$\frac {x_i} {\sum^n_{i=1} x_i}\$. If an option has received zero votes so far, it is simply not included in the summation (to avoid \$\log(0)\$).  For our purposes, the logarithm can be in any base of your choice.
$$H(X) = \sum^n_{i=1} P(x_i) I(x_i) = -\sum^n_{i=1} P(x_i) \log_b P(x_i)$$
As an example, the entropy of \$[3,2,1,1]\$ is approximately \$1.277\$, using base \$e\$.
The next step is to determine what voting pattern leads to the greatest increase in entropy.  I can vote for any subset of options, so for example my vote could be \$[1,0,1,0]\$.  If these were my votes, then the final tally is \$[4,2,2,1]\$.  Recalculating the entropy gives \$1.273\$, giving a decrease in entropy, which means this is a terrible attempt at disruption.  Here are some other options:
don't vote
[3,2,1,1] -> 1.277

vote for everything
[4,3,2,2] -> 1.342

vote for the 1s
[3,2,2,2] -> 1.369

vote for the 2 and 1s
[3,3,2,2] -> 1.366

From this, we can conclude that the optimal voting pattern is \$[0,0,1,1]\$ since it gives the greatest increase in entropy.
Input
Input is a non-empty list of non-increasing, non-negative integers.  Examples include \$[3,3,2,1,0,0]\$, \$[123,23,1]\$, or even \$[4]\$.  Any reasonable format is allowable.
Output
Output is a list (the same length as input) of truthy and falsey values, where the truths represent the options for which I should vote if I desired to cause maximal disruption.  If more than one voting pattern gives the same entropy, either one can be output.
Winning Criterion
This is code-golf, fewer bytes are better.
Test Cases
[3,2,1,1] -> [0,0,1,1]  (from 1.227 to 1.369)

[3,3,2,1,0,0] -> [0,0,0,1,1,1] (from 1.311 to 1.705)

[123,23,1] -> [0,1,1] (from 0.473 to 0.510)

[4] -> [0] OR [1] (from 0 to 0)

[7,7,6,6,5] -> [0,0,1,1,1] (from 1.602 to 1.608)

[100,50,1,1] -> [0,1,1,1] (from 0.707 to 0.761)

I wonder what would happen if we wanted to decrease entropy.

The test cases seem to be consistent with the heuristic "Increase the below-average values." Could you include some trickier test cases?

@xnor given that entropy is maximised with a uniform distribution, that's going to be a good heuristic! In fact, it might even be always the optimal strategy.. Perhaps someone can think of a good edge case?

Mathematica, 19 44 bytes
...(loud complaining)
(x=Median@#[[;;Mod[Length@#,2]-3]];#≤x&/@#)&

Test:
{Test, data, goes, here};
(x=Median@#[[;;Mod[Length@#,2]-3]];#≤x&/@#)&
%%+Boole/@%

This fails for {100,50,1,1} where it returns {False, False, True, True}, resulting in an entropy of 0.758. {False, True, True, True} yields an entropy of 0.761.

@IPoiler thanks for finding that testcase.

(cries and dies)

@PhiNotPi No problem, it was tricky. The initial entropy if you'd like for your edit is 0.707. @CatsAreFluffy I suspect there's a way to use a weighted average or even the Median for a relatively short code. It's difficult since MMAs built-in Entropy doesn't use the same formula given.

Per here This should be deleted.

..Fixed. (more loud complaining)

Pyth - 25 bytes
hosm*FlBcdsGfT=G+VQN^U2lQ

Test Suite.

MATL, 24 bytes
FTinZ^tG+!ts/tYl*s4#X<Y)

This works with version 13.0.0 of the language/compiler, which is earlier than the challenge.
Try it online!
Explanation
FT        % array [0 1]
in        % take input and push its length
Z^        % Cartesian power. This gives all possible vote patterns, each on a row
t         % duplicate (will be indexed into at the end to produce the result)
G         % push input again
+         % element-wise addition with broadcast
!         % transpose
ts/       % duplicate. Divide each column by its sum
tYl       % duplicatte. Take natural logarithm
*         % element-wise multiplication
s         % sum of each column. Gives minus entropy produce by each vote pattern
4#X<      % arg max
Y)        % index into original array of voting patterns. Implicitly display

Example
Here's an example of how it works. For input [3 2 2], the array of possible voting patterns (produced by Z^) is
[ 0 0 0
  0 0 1
  0 1 0
  0 1 1
  1 0 0
  1 0 1
  1 1 0
  1 1 1 ]

where each row is a pattern. This is added to the original [3 2 0] with broadcast (G+). That means [3 2 0] is replicated 8 times vertically and then added element-wise to give
[ 3 2 2
  3 2 3
  3 3 2
  3 3 3
  4 2 2
  4 2 3
  4 3 2
  4 3 3 ]

This is transposed and each column is divided by each sum (!ts/):
[ 0.4286    0.3750    0.3750    0.3333    0.5000    0.4444    0.4444    0.4000
  0.2857    0.2500    0.3750    0.3333    0.2500    0.2222    0.3333    0.3000
  0.2857    0.3750    0.2500    0.3333    0.2500    0.3333    0.2222    0.3000 ]

Multiplying by its logarithm and summing each column (tYl*s) gives minus the entropy:
[ -1.0790   -1.0822   -1.0822   -1.0986   -1.0397   -1.0609   -1.0609   -1.0889 ]

The minus entropy is minimized (4#X<) by the 4th vote pattern, which corresponds (Y)) to the final result [0 1 1].

Jelly, 17 bytes
LØ.ṗ+ḟ0÷SḋÆl$ƊɗÐṂ

Try it online!
How it works
LØ.ṗ+ḟ0÷SḋÆl$ƊɗÐṂ - Main link. Takes a list A on the left
L                 - Length of A
 Ø.ṗ              - Cartesian power of [0, 1] to the length of A
              ɗÐṂ - Output the bitlist B with the minimum value f(B, A):
    +             -   Add the elements of B to A
     ḟ0           -   Remove any zeros
             Ɗ    -   Last 3 links as a monad g(A+B \ {0}):
       ÷S         -     Divide each by the sum
            $     -     Last 2 links as a monad h([A+B \ {0}] ÷ sum):
          Æl      -       Natural log of each
         ḋ        -       Dot product


text:
The Holier Numbers
As we learned from The Holy Numbers, there are 5 holy digits (0, 4, 6, 8, 9), and positive integers consisting solely of those digits are holy. Additionally, the holiness of a number is the sum of the holes in the number (+2 for every 0 or 8, and +1 otherwise).
Now, there is an additional property to take into consideration, to truly and accurately represent the holiness of a number. You see, it's not just the number of holes in the digit that matters, but also where in the number it occurs.
Consider the number 88. By our old rules, it would have a holiness of 4. But that's hardly fair! The 8 on the left is doing more work than the other 8 - 10 times the work! It should be rewarded for its work. We will reward it with extra holiness points equal to the total holiness of all the digits to its right (including the extra holiness points granted by this rule to the digits on its right), minus 1.
Here are more examples to take into consideration:
Number: 8080
Digital holiness: (2 + 7 - 1) + (2 + 3 - 1) + (2 + 1 - 1) + (2 + 0 - 1)
Total holiness: 15

Number: 68904
Digital holiness: (1 + 5 - 1) + (2 + 2 - 1) + (1 + 1 - 1) + (2 + 0 - 1) + (1 + 0 - 1)
Total holiness: 10

All of the digits are appropriately rewarded for their work with extra holiness, and all is well. We shall call this property "enhanced holarity".
In the great language Python, an algorithm for calculating enhanced holarity might look something like this:
# assumes n is a holy number
def enhanced_holarity(n):
    if n < 10:
        return 1 if n in [0, 8] else 0
    else:
        digits = list(map(int,str(n)[::-1]))
        res = []
        for i,x in enumerate(digits):
            res.append(enhanced_holarity(x))
            if i > 0:
                res[i] += sum(res[:i])
        return sum(res)

The Challenge
Given an integer n > 0, output the first n Holy Numbers, sorted by ascending enhanced holarity, using numeric value as a tiebreaker. You may assume that the input and output will be no greater than the maximum representable integer in your language or 2^64 - 1, whichever is less.
For reference, here are some test cases (input, followed by output):
25
4, 6, 9, 44, 46, 49, 64, 66, 69, 94, 96, 99, 0, 8, 84, 86, 89, 40, 48, 60, 68, 90, 98, 80, 88

100
4, 6, 9, 44, 46, 49, 64, 66, 69, 94, 96, 99, 444, 446, 449, 464, 466, 469, 494, 496, 499, 644, 646, 649, 664, 666, 669, 694, 696, 699, 0, 8, 84, 86, 89, 844, 846, 849, 864, 866, 869, 894, 896, 899, 40, 48, 60, 68, 90, 98, 404, 406, 409, 484, 486, 489, 604, 606, 609, 684, 686, 689, 80, 88, 804, 806, 809, 884, 886, 889, 440, 448, 460, 468, 490, 498, 640, 648, 660, 668, 690, 698, 840, 848, 860, 868, 890, 898, 400, 408, 480, 488, 600, 608, 680, 688, 800, 808, 880, 888

200
4, 6, 9, 44, 46, 49, 64, 66, 69, 94, 96, 99, 444, 446, 449, 464, 466, 469, 494, 496, 499, 644, 646, 649, 664, 666, 669, 694, 696, 699, 944, 946, 949, 964, 966, 969, 994, 996, 999, 4444, 4446, 4449, 4464, 4466, 4469, 4494, 4496, 4499, 4644, 4646, 4649, 4664, 4666, 4669, 4694, 4696, 4699, 0, 8, 84, 86, 89, 844, 846, 849, 864, 866, 869, 894, 896, 899, 40, 48, 60, 68, 90, 98, 404, 406, 409, 484, 486, 489, 604, 606, 609, 684, 686, 689, 904, 906, 909, 984, 986, 989, 4044, 4046, 4049, 4064, 4066, 4069, 4094, 4096, 4099, 80, 88, 804, 806, 809, 884, 886, 889, 440, 448, 460, 468, 490, 498, 640, 648, 660, 668, 690, 698, 940, 948, 960, 968, 990, 998, 4404, 4406, 4409, 4484, 4486, 4489, 4604, 4606, 4609, 4684, 4686, 4689, 840, 848, 860, 868, 890, 898, 400, 408, 480, 488, 600, 608, 680, 688, 900, 908, 980, 988, 4004, 4006, 4009, 4084, 4086, 4089, 800, 808, 880, 888, 4440, 4448, 4460, 4468, 4490, 4498, 4640, 4648, 4660, 4668, 4690, 4698, 4040, 4048, 4060, 4068, 4090, 4098, 4400, 4408, 4480, 4488, 4600, 4608, 4680, 4688, 4000, 4008, 4080, 4088

This hole idea is holarious.

What do you mean by "output will be no greater than..."? As in the output won't have any number greater than 2^64 - 1? If that's the case it's probably worth figuring out which input first generates such numbers, so people can test their answers.

@FryAmTheEggman No greater than means less than or equal to. I'll update the post with some maximums for various integer sizes.

Your python code does not work for 6, it produces a holines of 0.

Python 2, 138 122 bytes
This looks for holy numbers up to 5N for an input N, which is ridiculously slow:
e=lambda s:s and(s[0]in'08')+e(s[1:])*2or 0
lambda N:sorted([`x`for x in range(5**N)if set(`x`)<=set('04689')][:N],key=e)

Here the limit is 5N2, and you can actually run the test cases, at the cost of a single byte:
e=lambda s:s and(s[0]in'08')+e(s[1:])*2or 0
lambda N:sorted([`x`for x in range(5*N*N)if set(`x`)<=set('04689')][:N],key=e)

The first snippet is valid, as 5N ≥ 5N2 for all positive integers N.

Oh, wait, I missed something.. Too tired for this.

Lua, 317 Bytes
I had some troubles doing this, some things in Lua don't work as I think it does. I will have to try and play with them if I want to golf this down.
You can test lua online by replacing arg[1] by the number of elements you want :).
function f(y)h=0(y..''):reverse():gsub(".",function(c)h=c:find("[08]")and 1+h or h end)return h end
x,a=0,{}while(#a<arg[1]+0)do a[#a+1],x=(x..''):find("^[04689]*$")and x or nil,x+1 end
for i=1,#a do m=1
for j=1,#a do x=a[m]m=(f(x)~=f(a[j])and f(x)>f(a[j])or x>a[j])and j or m
end end print(a[m])table.remove(a,m)end

Ungolfed and explanations
function f(y)                     -- function returning the enhanced holiness of a holy number
  h=0                             -- h is the cumulated holyness of processed digits
  (y..''):reverse()               -- reverse the digits in y
         :gsub(".",function(c)    -- iterate over each digits
     h=c:find("[08]")and 1+h or h -- ternary based on the digit being [08] or [469]
   end)
  return h                        -- return h
end

x,a=0,{}                          -- initialise a counter, and the array of holy numbers
while(#a<arg[1]+0)                -- iterate until we have n holy numbers
do
  a[#a+1]=(x..'')
      :find("^[04689]*$")         -- if we can't find an unholy digit
             and x or nil         -- insert x into a
  x=x+1                           -- increment x anyway
end

for i=1,#a                        -- iterate n times(current size of a)
do
  m=1                             -- m is the index of the lowest value
  for j=1,#a                      -- iterate over a
  do
    x=a[m]                        -- x is shorter to write than a[m]
    m=(f(x)~=f(a[j])              -- nested ternaries, translated in
        and f(x)>f(a[j])          -- nested if below
        or x>a[j])and j or m
  end
  print(a[m])                     -- output a[m]
  table.remove(a,m)               -- remove it from the table a
end

The nested ternaries used for the new value of m can be translated in nested ifs as:
if(f(a[m])~=f(a[j])) then         -- if a[m] and a[j] don't have the same holyness
  if(f(a[m])>f(a[j])) then m=j end-- compare by holyness
else
  if(a[m]>a[j]) then m=j end      -- else, compare by numeric value

Also, I would have loved to replace the nested for by using table.sort, but, for a reason I don't know, the following doesn't work despite not producing an infinite loop or crushing the sort function.
table.sort(a,function(i,j)
    return f(i)~=f(j)
         and f(i)>f(j)
         or i>j
end)

JavaScript (ES6), 166 165 bytes
f=n=>[...Array(n)].map((_,i)=>i.toString(5)).sort((a,b)=>e(a)-e(b),e=n=>'0b'+[...n.replace(/./g,c=>'10010'[c])].reverse().join``).map(n=>+n.replace(/./g,c=>"04689"[c]))

Edit: Saved 1 byte by returning an array of strings.
Ungolfed:
function base5_to_extended_holiness_binary(c) {
    return "10010"[c];
}
function extended_holiness(n) {
    var binary = n.toString(5).replace(/./g, base5_to_extended_holiness_binary);
    binary = s.split("").reverse().join("");
    return parseInt(s, 2);
}
function extended_holiness_sort(a, b) {
    return extended_holiness(a) - extended_holiness(b);
}
function base5_to_holy_number(c) {
    return "04689"[c];
}
function list_by_extended_holiness(n) {
    var array = new Array(n);
    for (var i = 0; i < n; i++)
         array[i] = i;
    array = array.sort(extended_holiness_sort);
    for (var i = 0; i < n; i++)
        array[i] = parseInt(array[i].toString(5).replace(/./g, base5_to_holy_number);
    return array;
}