text:
Diamond Puzzles!
Explanation:
Last year in math class, on homework we would occasionally get these extremely simple, although equally annoying questions called diamond puzzles. These were basically questions where we would be given a sum, and a product then were asked to find the two numbers which when multiplied give the product, and when added give the sum. These drove me crazy, since the only way I knew how to solve them (in Algebra I) was to just list the factors of the product then see which ones added to make the sum. (Since I didn't know how to use Quadratics at the time)  Not to mention, they weren't exactly challenging math. However, It just occured to me that I should have just written a program. So that is your challenge today! Write a program that can solve a diamond puzzle.
Examples

Apologies for the blurry image, its the best I could find. Also, ignore the numbers in bubbles.The top of the diamond is the product, the bottom is the sum, the right and left are the two numbers.
Answers are as follows: (These are also your test cases)

9, -7
-2, -1
5, 8
-9, -9

Rules:

You may not use any pre-defined functions or classes which accomplish this for you.
Your code must be a complete program, or function which either returns or prints the answers once it finds them
The input is the sum and product, which are inputted as a function parameters or user input

Specifications:

Assume that the two numbers, the sum, and the product will always be an integer.
The two answers will both be between -127 to 127.
Your input will be two integers (Sum and Product).

Remember this is code-golf, so shortest byte count wins. Please title your answer with the standard ##Language Name, Byte Count
Edit:
Also, Doorknob pointed out that this is essentially "factor a quadratic of form x^2 + bx + c,". That is another way to think about and approach this challenge. :D

This is essentially "factor a quadratic of form x^2 + bx + c," correct?

b = -(x+y), c = (x*y)

Simplifying (x + n)(x + m) gives you x^2 + (n+m)x + (n*m), so factoring said quadratic is basically equivalent to this question (if I'm understanding it correctly).

@Doorknob冰 yeah you are correct. I am guessing I'm about to be marked as a duplicate. :(

Well, I don't think we have a "factor x^2+bx+c" question yet anyway. Just pointing out that the problems are very similar.

Does the order of the output pair matter?

@AlexA. No. You can output any order you like.

You may not use any pre-defined functions or classes which accomplish this for you. Does this cover built-ins that solve and/or factor polynomials as well?

Jelly, 15 11 10 bytes
Hð+,_ðH²_½

Try it online!
The following binary code works with this version of the Jelly interpreter.
0000000: 48 98 2b 2c 5f 98 48 8a 5f 90  H.+,_.H._.

Idea
This is based on the fact that

Code
Hð+,_ðH²_½    Left input: s -- Right input: p

 ð   ð        This is a link fork. We define three links, call the left and right
              link with the input as arguments, then the middle link with the
              results as arguments.

H             Left link, dyadic. Arguments: s p

H             Halve the left input.

     ðH²_½    Right link, dyadic. Arguments: s p

      H       Halve the left input.
       ²      Square the result.
        _     Hook; subtract the right input from the result.
         ½    Apply square root to the difference.

 ð+,_         Middle link, dyadic. Arguments: (results of the previous links)

  +           Compute the sum of the results.
    _         Compute the difference of the results.
   ,          Pair.

That is a very nice online compiler. I wish they had one like that for java.

@AshwinGupta Dennis made that himself, actually ;) For Java, there's always Ideone.

@Doorknob冰 yeah I know his online compiler is so cool. I have been on Ideone, its good and all but it doesn't have multiclass support which is a problem. I have no way to test my more complex programs at school D:. Plus, it doesn't work on an iPad browser either which believe it or not has to be a requirement since that is the computing device we have been provided with...

Unless someone can beat 14, I think you won.

OK, Jelly is now officially insanely short. I've got to learn this language right after I finish wrapping my head around Pyth...

Unicorn, 4650 2982 1874 1546
[ ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨  (    ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨     ( ) )  2         ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨  (  ✨✨✨✨✨✨✨   4   ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨     ( ) )    ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ ]

Now with goats, rainbows, and sparkles!
Hopefully shorter than Java.

Uses a custom encoding which can be applied with ApplyEncoding
Explanation
How does this work??? With the magic of unicorns (and a little code).
Unicorn is compiled into JavaScript
Each section is separated by a space, and each section represents a character in the JavaScript code.
If the section contains unicorns, the section's character is the section's length, converted to a char code (e.g. 32 unicorns would be a space)
If the section contains goats, the section's length is doubled and then converted to a char code.

If the program's special chars don't show, here's a picture:

This is non competing because Unicorn was made after this challenge was posted.

What on earth is going on here? I just see boxes. ;-;

@Mauris aww :( I'll post an image of the program so everyone can see it's glory

Haha, you maybe want to provide an explanation :D

"This is non competing because Unicorn was made after this challenge was posted" - and if the Unicorn was made before this question's posted, it'd obviously would have chance to win ;D

LOL okay this is my favorite even though I can't accept it since it is so darn long.

You seriously made this language like an hour ago?! You may be the fastest programming (esoteric) language writer ever!

Well this is a new scenario... I inspired an esolang that's brought to life in just an hour. Well, now I've got to +1 for the language itself ;)

"Hopefully shorter than Java." You deserve a +10 just for that ;)

@ETHproductions and downgoat, just because of that im writing a java answer now... :D

@Doᴡɴɢᴏᴀᴛ, sorry to disappoint you. Java is about 18 times shorter than that.

This is right now 18,740 percent larger than the current shortest answer.

What do the sparkles and rainbows do?

@RikerW Sparkles are multiplied by 6, rainbows are multiplied by 4

Okay, but you got rid of the goats!  BTW, I can see the rainbows, sparkles, and previously the goats but not the unicorns? Whatever. :P

Can I have the source code for the compiler? Git Link maybe?

@AshwinGupta you can click "Unicorn" at the top, here's the Github: https://github.com/vihanb/Unicorn

@Doᴡɴɢᴏᴀᴛ yup just realized that. Thanks.

JavaScript ES6, 45 39 37* bytes
(q,p)=>[x=p/2+Math.sqrt(p*p/4-q),p-x]

* Thanks to Dennis!

I'm +1 ing you because this is the first answer I can actually understand (sort of). LOL

dc, 16
?ddd*?4*-v+2/p-p

Reads sum then product from separate lines of STDIN.  -ve numbers must be entered with an underscore instead of a minus sign.  e.g.
$ { echo 2; echo _63; } | dc -e'?ddd*?4*-v+2/p-p'
9
-7
$

Explanation:
Same basic quadratic solution for sum = a + b and product = a * b.  This calculates solution a as:
a = [ sum + √( sum² - 4 * product ) ] / 2

And calculates solution b as:
b = sum - a

Expanded:
?                   # push sum to stack
 ddd                # duplicate 3 times (total 4 copies)
    *               # sum squared
     ?              # push product to stack
      4*            # multiply by 4
        -           # subtract (4 * product) from (sum squared)
         v          # take square root of (sum squared) - (4 * product)
          +         # add sum to square root of (sum squared) - (4 * product)
           2/       # divide by 2 to give solution a
             p      # print with newline and without pop
              -     # subtract solution a from sum to give solution b
               p    # print with newline and without pop

Dividing by 2 is done late to prevent loss precision.  It is possible to divide by 2 earlier, but this requires fractional precision which needs more characters.

Wait, what?  This ended up shorter than APL, Pyth and CJam??? Woohoo!

TeaScript, 22 bytes 30 31
[d=y/2+$s(y*y/4-x),y-d

Not that bad. Would be much shorter if I could of gotten some golfing features finished earlier such as unicorn unicode shortcuts
Try it online

"unicorn shortcuts" I like the sound of that! ;)

@ETHproductions haha, that was autocorrect :p though unicorn shortcuts could be interesting...

Pyth, 21 18 bytes
Saved 3 bytes thanks to @Dennis
,J/+@-^Q2*4E2Q2-QJ

Test suite
My second Pyth program ever, so it can probably be golfed with built-ins. Suggestions are welcome!
How it works
,J/+@-^Q2*4E2Q2-QJ   Implicit: Q = first line of input
,                    Create and output a list of these items:
 J                     Set variable J to the result of these operations:
      ^Q2                Square Q.
     -   *4E             Subtract 4*(next line of input).
    @       2            Take the square root.
   +         Q           Add Q.
  /           2          Divide by 2.
                       The list is currently [J].
               -QJ     Push Q-J; the list is now [J, Q-J].
                     EOF; list is sent to output.

(This explanation may not be 100% correct; I'm not very familiar with Pyth.)
Note that / is integer division. By replacing it with c, we could make this work with non-integer inputs as well.

Beaten you by one byte :P You should consider switching ;D

This explanation may not be 100% correct...???

@DigitalTrauma I'm not 100% certain that's how it works (specifically the J), but it's what I gathered from reading the docs.

Yes, J is an auto-assigning variable and gets set the first time it is used. The only part that doesn't seem quite right is The list is currently [J]. , takes exactly two arguments and combines them in a list.

MATL, 33 bytes
-100:100t!2$t+i=bb*i=&2#2$1fv101-

Outputs the two numbers in two different lines. If no solution exists it produces no output. If several solutions exist it produces only the pair of numbers corresponding to one solution.
Example
The following was run in Octave with the current GitHub commit of the compiler.
>> matl -r '-100:100t!2$t+i=bb*i=&2#2$1fv101-'
> 2
> -63
 9
-7

Explanation
-100:100           % row vector -100, -99, ..., 100
t!                 % duplicate and transpose into column vector
2$t                % duplicate the two vectors
+                  % sum with singleton expansion (all combinations)
i=                 % does it equal input? Produces logical matrix
bb                 % move the two vectors to top
*                  % multiply with singleton expansion (all combinations)
i=                 % does it equal input? Produces logical matrix
&                  % logical "and"
2#2$1f             % find row and column of the first "true" value in logical matrix
v101-              % concatenate vertically and subtract 101

Out of curiosity, would the program in "explanation" form actually run on a MATL compiler? The syntax is awfully split.

Yes, you can paste the program in separate lines, for example copying the listing from the explanation. You type matl and press "enter"; then paste the program and finish with a blank line. What do you mean the syntax is awfully split? MATL uses reverse polish (postfix) notation, perhaps that's confusing you?

Julia, 46 44 32 bytes
f(b,c)=(x=b+√(b^2-4c))/2,b-x/2

An function f that takes the sum and then the product.
My first Julia answer.  @AlexA., you should be proud of me.
Thanks @Dennis and @Alex A. for all the help.  I got to cross out the 44. :P

40 bytes: f(b,c)=b/2+√(b^2/4-c),b/2-√(b^2/4-c)

34 bytes: f(b,c)=b/2+√(x=b^2/4-c),b/2-√x

@AlexA. - You're going to make a meme happen by suggesting improvements to this one...

32 bytes: f(b,c)=(x=b+√(b^2-4c))/2,b-x/2

Thank you so much guys.  I knew there must be a shorter way to do square roots.

@Dennis how does your 32 byte one work?  I get the 34 byte with assigning x to b^2/4-c, but in yours x equals b+√(b^2-4c)?

The answers are x/2 = (b + √(b^2-4c))/2 and b - x/2 = b - (b+√(b^2-4c))/2 = (2b - b - √(b^2-4c))/2 = (b - √(b^2-4c))/2.

It's just like the regular quadratic formula that's been beaten into our heads since we were but wee babbies.

Python 3, 49 44 bytes
There are probably some ways to golf this down even further, but this looks pretty good as is.
def f(s,p):s/=2;d=(s*s-p)**.5;return s+d,s-d

The sign of the difference is incorrect; it should be s/2-d. Also, d=(s*s/4-p)**.5 saves a few bytes.

@Dennis Oops, you're right. Fixed and golfed.

Java , 82 (69 λ) bytes with quadratic formula (127 (114 λ) bytes brute-force)
Brute-Force: (Vanilla, Java 7)
int[] n(int s,int p){for(int a=-100;a<=100;a++)for(int b=-100;b<=100;b++) if(a+b==s&&a*b==p)return new int[]{a,b};return null;}

λ-enhanced: (Java 8)
(s,p)->{for(int a=-100;a<=100;a++)for(int b=-100;b<=100;b++) if(a+b==s&&a*b==p)return new int[]{a,b};return null;}

Assign lambda to java.util.function.BiFunction<Integer, Integer, int[]> and call apply().
Plain old brute-force approach. Just the working function is here, and since Java can't return multiple values, we return a 2-element int array with the required numbers.
The full brute-force approach based program can be found here on ideone.com, with λ version here.
Golfing this involved removing all unnecessary braces.
Ungolfed:
int[] n(int s,int p){//sum and product as function parameters,in that order
    for(int a=-100;a<=100;a++){//iterate first no. from -100 to 100
        for(int b=-100;b<=100;b++){//iterate second no. from -100 to 100
            //if the 2 nos. satisfy the diamond-puzzle condition,
            //pack them in an int array and return them
            if(a+b==s&&a*b==p)return new int[]{a,b};}
     }//if no such pair exists, return null
return null;}

Quadratic Approach: (Vanilla, Java 7)
int[] n(int s,int p){int x=s+(int)Math.sqrt(s*s-4*p);return new int[]{x/2,s-x/2};}

λ-enhanced: (Java 8)
    (s,p)->{int x=s+(int)Math.sqrt(s*s-4*p);return new int[]{x/2,s-x/2};}
(Usage as for brute-force λ above).
Parameters and return criteria are the same as the brute-force solution above.
Uses the good old quadratic formula used by almost all other answers here, and cannot be golfed down much further unless someone helps me out here. It's pretty clear so I'm not including an ungolfed version.
The full quadratic approach based program is here on ideone.com, with λ version here.

AHHA yes thank you. I was waiting for the Java answer. Also, I was waiting for someone to use for loops and brute force with the factors. I guess I got the two for one deal. +1

Java beat unicorn :( I'd +1 but I've used my daily vote limit

convey, 52 bytes
{?~1
4*"v
 v*#2
`-.v
*%2v
.10-`
v0 v"
"-v,<
>,+
 2%}

Try it online!
Golfed version of this answer.

APL, 27 21 bytes
h(+,-).5*⍨⊣-⍨h×h←.5×⊢

This is a dyadic function train that accepts integers on the right and left and returns an array. To call it, assign it to a variable.
Ungolfed:
                h←.5×⊢       ⍝ Define a train h for halving the input
              h×             ⍝ b^2/4
          ⊣-⍨                ⍝ b^2/4 - c
      .5*⍨                   ⍝ sqrt(b^2/4 - c)
h(+,-)                       ⍝ Return the halved pair

Try it online
Saved 6 bytes thanks to Dennis!

CJam, 18 bytes
q~2d/_2#@-mq_2$+p-

Try it online!
How it works
q~                  e# Read an evaluate all input. STACK: product sum
  2d/               e# Divide the sum by 2.0.
     _              e# Push a copy of the result.
      2#            e# Square the copy.
        @-          e# Rotate the product on top and subtract it from the square.
          mq        e# Apply square root.
            _2$     e# Push copies of the root and the halved sum.
               +p   e# Add and print.
                 -  e# Subtract the originals.

Japt, 28 22 21 20 bytes
[X=V/2+(V²/4-U ¬V-X]

Input is made in the form of -63 2.
Explanation:

U and V are the two inputs (-63 and 2 in the first case)
² squares the number
q extracts the square root

I was just writing up an answer for this; that is, until I saw yours. Nice work! By rearranging the first part and using a couple more Unicode shortcuts, we can achieve 21 bytes: [X=ºV²-4*U ¬+V)/2V-X] Without the shortcuts: [X=((V²-4*U q +V)/2V-X] I should really make the trailing ] unnecessary in the next version...

@Eth Ok, ¬ is a great thing.

MathCAD 15. 38 Bytes

With a mathematical formula, programming in MathCAD is easy.  The language is even designed to handle complex numbers with ease.  However there are shorter languages that can solve the problem.

, 21 chars / 30 bytes
[x=í/2+√ í²/4-î⦆,í-x]

Try it here (Firefox only).
Meh. This should be visual enough for y'all to get the idea; however, if you must, î = input1, í = input2.

wx d, 14 12 bytes
Just W with a few instructions added.
○Äπ√akû▀╧Θ°v

Decompressed:
a*S4*-Q+2/:aS-

J, 12 bytes
1-@>@{p.@,&1

Try it online!

APL (Dyalog Unicode), 14 bytesSBCS
⊣(⊢,-)(⊢×-)⍣¯1

Try it online!
A tacit function whose left arg is the sum and the right is the product. Finds one solution to the quadratic equation using the built-in numerical solver, and then gives both solutions based on the result.
The "power operator" f⍣n runs the function f n times, but if n is negative, runs the inverse of f -n times. The inverse of f is, in the numerical point of view, equivalent to solving the equation f x = y with a given value of y. Dyadic form a(f⍣n)y solves (a f x) = y.
How it works
⊣(⊢,-)(⊢×-)⍣¯1  ⍝ left: sum s, right: product p
      (⊢×-)     ⍝ A function that, when left-bound with s, computes x*(s-x)
           ⍣¯1  ⍝ Find one solution to x*(s-x)=p, i.e. x^2-sx+p=0
⊣(   )          ⍝ With s as left and x as right arg,
  ⊢,-           ⍝ Give (x,s-x)

PHP, 62 bytes
<?=($x=($p=$_GET[p])/2+sqrt($p*$p/4-$q=$_GET[q]))." ".($p-$x);

This could be pretty long but being full-featured PHP web-"program". Accepts the arguments via the "get" request.
Demo.

TI-BASIC, 20 bytes
Takes Q from Ans, and P from Prompt. Call like P:prgmNAME.
Prompt P
P/2+√(P²/4-Ans
{Ans,P-Ans

Very nice. Too bad for that Prompt statement being so long lol. I don't know TI-BASIC, but it could  be shorter if you were to put the code in a function and pass P as a parameter.

Actually, TI-BASIC is divided into "tokens"; Each of Prompt , P, /, 2, +, √(, ², 4, -, Ans, and { are one token, and each of these tokens is one byte. Also, TI-BASIC does not have functions. This is probably the shortest method.

Oh well thats intresting, I didn't realize that. But isn't each char a byte still in a technical sense? Like if I were to copy paste this into a text doc, I get 36 bytes. Or does this use special Unicode characters?

TI-BASIC is a calculator language, so this is what one sees. It is keyed into the calculator, not a text document or the like. Here are the one-byte tokens.

Ah okay I got you. Cool. I just was curious.

Not a problem! :) Thanks for asking.

source: Stack Exchange

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

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

sort: votes


text:
Pyth Practice 2
Time for another Pyth practice. I present here 8 problem statements with a Pyth solution each. These solutions are written by a Pyth beginner. He is quite happy about these solutions, since they are a lot shorter than his Python answers. Your task however is to show him better. Create equivalent but shorter programs.
This is a challenge about the the tricks and optimizations that can be used when golfing in Pyth. Pyth golfers may recognize many of the tricks involved, that lead to shorter solutions. However some problems will require some unusual approaches that are rarely used. Some of the tricks I've actually never seen in the wild. But no solution requires any bugs or strange behavior, that was not intentional by the designer(s) of Pyth. All answers must be valid for the most recent Pyth commit (2b1562b) as of this question's posting. You can use the Pyth interpreter for testing. It is up-to-date right now and I don't expect any big changes in Pyth, that will invalidate optimal solutions or make shorter solutions possible. The online interpreter also features the new Character Reference. Since it is pretty new, you can (should) also use the old docs, in case something is incorrect or missing.
Goal: The reference solutions total 81 bytes. Your goal is to beat that by as much as possible. The submission that solves all 8 problems with the smallest total number of bytes wins. Tiebreaker is the submission date.
Of course only submissions are valid, which contain solutions for all 8 problems. You can use the reference implementation, if you can't improve the score of one (or more) particular problem.
Your solutions must print the exact same output as the reference solutions. Except for an optional trailing newline.
Since this is a Pyth practice, only programs written in the language Pyth are allowed.
Answering: Please spoiler your entire answer, except for your total score. It is intended that you do not look at other people's answers before submitting your own. You can create spoilers by putting >! in front of every line, like:
>! Problem 1: V9m?>dNd0S9 (11 bytes)
>! Problem 2: VTN)VGN (7 bytes)
>! ...

I hope I haven't chosen too difficult or too trivial problems. Hoping for a lots of participators and for everyone to gain a few new insights into Pyth. Happy golfing!
Problem 1:
Create the following 9x9 matrix and print it:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 0, 3, 4, 5, 6, 7, 8, 9]
[0, 0, 0, 4, 5, 6, 7, 8, 9]
[0, 0, 0, 0, 5, 6, 7, 8, 9]
[0, 0, 0, 0, 0, 6, 7, 8, 9]
[0, 0, 0, 0, 0, 0, 7, 8, 9]
[0, 0, 0, 0, 0, 0, 0, 8, 9]
[0, 0, 0, 0, 0, 0, 0, 0, 9]

Reference solution (Link):
V9m?>dNd0S9 (11 bytes)

Problem 2:
Print all digits and all letters on separate lines:
0
...
9
a
...
z

Reference solution (Link):
VTN)VGN (7 bytes)

Problem 3:
Find the lexicographically smallest palindrome, that is lexicographically bigger or equal than an input string containing lowercase letters and is of the same than the input string.
a -> a
abc -> aca
adcb -> adda

Reference solution (Link):
hf&gTzqT_T^Glz (14 bytes)

Problem 4:
Check, if a number is in the range [0, input number). This should also work for floats.
4, 6 -> True
5.5, 6 -> True
6, 6 -> False
6, 6.1 -> True

Reference solution (Link):
&gQ0<QE (7 bytes)

The reference format is to be tested value<newline>end value. You can choose a different input format however. Important is only, that you accomplish the problem statement and produce the correct results.
Problem 5:
Parse an input string of the format "\d+[a-zA-Z]+". Notice that the number really has to be a number, not a string containing digits.
'123Test' -> [123, 'Test']

Reference solution (Link):
A.ggk\Az,sGH (12 bytes)

Problem 6:
Compute the sum of numbers, that are separated by one or multiple commas. You can assume that there is at least one number in the string.
11,2,,,3,5,,8 -> 29

Reference solution (Link):
svM:z",+"3 (10 bytes)

Problem 7:
Read positive integers from the input until you get the number 0. Print the sum of all numbers.
Reference solution (Link):
WJE=+ZJ)Z (9 bytes)

Problem 8:
Sum up all elements of a square matrix, except the ones of the main diagonal (left upper corner to right bottom corner).
Reference solution (Link):
-ssQs.e@bkQ (11 bytes)

I really like the idea of language-specific questions (and I have upvoted this one). But I thought language-specific questions were frowned upon in PPCG?

@LuisMendo I think language-specific quesitions are only frowned upon, if the reason behind the question is a general dislike against golfing languages like CJam, Pyth, ..., or because the OP only understands certain languages. This here is a little different. This question is mainly designed to show some of the more hidden features of a popular (on PPCG) language. In a way it's like a collection of tricks. It doesn't make sence to allow it to every language. Here's a Meta-post about this topic: link

In 6, are the numbers positive single-digit integers?

@xnor You can assume that they are positive, but they might consist of more than one digits. I'll change the test case.

@Jakube I see. Thanks for the link!

In 4, which one is the end value and which is the one being tested?

@Maltysen I took the second one as the end value and the first one as the one being tested. You can change the order though. I'll clarify this in the post.

In 4, why is 5.5, 6 a False case?

@isaacg Oops. It should be true. I'll correct it.

For problem 5, do we need to handle leading zeros? If so, could you add a test case?

@isaacg No. You can assume that there are no leading zeros. The reference solution also can't handle those.

For problem 7, are the numbers non-negative?

@isaacg Yes, I probably should have specified this.

I'm voting to close this question as off-topic because it is a multi-part challenge with no interaction between the parts

@pppery Perhaps it should be retagged as a [tag:tips] question?

@JoKing I don't see how this fits into the scope of [tag:tips]

@ppery For questions asking for tips on a specific piece of code, to make it a better answer to a programming challenge that is on-topic on this site. In this case it would be multiple pieces of code, though answers would be expected to be more detailed.

@JoKing Is it really worth the time arguing about a 4 year old post (that has an accepted answer, and overall good feedback)? At the time it was clearly accepted (see the meta post I linked in the comments above).

@Jakube Rules have changed to no longer permit that sort of question. Therefore, all questions of this type must be closed. The fact that this question is old is utterly irrelevant.

54 bytes
Here are the intended solutions. Except for task 8 all solutions were found.

 1. j.tmLdS9Z (9 bytes) using map for left-map, transpose and fill with zeros
 2. \nMTjG (5 bytes) use newlines for map
 3. h.f_IZ1z (8 bytes) generate the possible strings with .f
 4. %IQE (4 bytes) found a usecase, where the invariant operator needs 2 parameters
 5. ,J.vz-zJ (8 bytes) .v evaluates only the first statement of a string and ignores the rest
 6. ssMcz\, (7 bytes) s"" = 0
 7. u+GE0 (5 bytes) reduce until it reaches a know number
 8. ss.DVQUQ (8 bytes) delete the diagonal using vectorization

Damn, I forgot U did l on lists!

Nice on beating isaacg in his own language.

59 58 56 bytes
Problem 1:

 j.tmLdS9Z (9 bytes)

Problem 2:

 MTjG (5 bytes) (The first character is a newline)

Problem 3:

 h.f_IZ1z (8 bytes)

Problem 4:

 %IQE (4 bytes)

Problem 5:

 ,J.vz-zJ (8 bytes)

Problem 6:

 srXz\,d7 (8 bytes)

Problem 7:

 u+GE0 (5 bytes)

Problem 8:

 ss.DR~hZQ (9 bytes)

66 bytes

 1. 10 bytes: V9+mZN}hN9
 2. 6 bytes: jUT)jG
 3. 8 bytes: h.f_IZ1z
 4. (reference implementation) 7 bytes: &gQ0<QE
 5. 11 bytes: ,sK-rzZG-zK
 6. 7 bytes: ssMcz\,
 7. 8 bytes: s<.Qx.QZ
 8. 9 bytes: ss.eXbkZQ

68 67 66 65 bytes
Task 1

 10 bytes: V9m*d>dNS9

Task 2

 5 bytes: \nMTjG, where \n is a newline

Task 3

 9 bytes: h.fqZ_Z1z

Task 4

 5 bytes: qQ%QE

Task 5

 Reference solution, 12 bytes: A.ggk\Az,sGH

Task 6

 7 bytes: ssMcz\,

Task 7

 8 bytes: s<.Qx.Q0

Task 8

 9 bytes: ss.DVQUlQ

 60 59  57 bytes

 1. 9 bytes: j.tmRdS9Z

 2. 6 bytes: jbUTjG

 3. 8 bytes: h.f_IZ1z

 4. 4 bytes: }sEU

 5. 8 bytes: ,K.vz-zK

 6. 7 bytes: ssMcz\,

 7. 8 bytes: s<FxB.Q0

 8. 11 10 7 bytes: ss.DVQU
 Previous version: ss.e+<bk>bh

Note that I developed this solutions completely independently of other answers, although I am quite late to the party.

Nice attempt. 3rd problem are 8 bytes though.

And I'm pretty sure, that the solution for problem 8 did not compile at the time back then. But I haven't tested it.

@Jakube Oh thanks for noticing!

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


text:
Can I live here?
In the game Terraria, one of the game mechanics involves building houses so that an NPC can move in. There is a strict set of rules for what counts as a valid house or not. Here is the list of rules:

The total area in the house must be at least 60 square tiles, but less than 750. Also, the size of the house including the outer frame must be at least one of these:
5x12
6x10
7x9
8x8
9x7
10x6
12x5
15x4

for simplicity's sake, you can safely assume that: a) All input houses will be rectangles, and b) no solid tile # will be inside of the house. Here is our 12x6 frame (drawn in beautiful ASCII):
############
#          #
#          #
#          #
#          #
############

The house must be covered in background walls. These are not solid tiles, but rather a wall behind the house in the third dimension. Holes are allowed, but no holes can be larger than 4x4. If there is a row or column of 5 or more space characters in a row, this is a hole larger than 4x4, and the house is invalid. Multiple holes are also allowed, but there must be at least a single wall apart.
############
#**********#
#**********#
#**********#
#**********#
############

############
#*    *    #
#*    *    #
#*    *    #
#******    #
############  (Still acceptable since neither hole is larger than 4x4 and there is a separator)

############
#    ******#
#***    ***#
#    ******#
#***    ***#
############  (Also still valid. No row or column of blank spaces is longer or taller than 4.)

There must be an entrance. This can be a door | on the sides or a platform - on the floor or ceiling. If the only entrance is on a corner, the NPC is unable to enter. Also, if you have a platform as the floor, you must have at least a single solid block for the NPC to stand on. This solid block cannot be directly adjacent to the side walls on the left or the right. These are all valid houses with entrances:
############
#**********#
|**********#
#**********#
#**********|
############  (Multiple doors, or doors up high are okay)

############
#**********#
#**********#
#**********#
#**********#
#######----#

#----#######
#**********#
#**********#
#**********#
#**********#
############

There must be at least one light source $, table T and chair C, although more is allowed. The light source can be in the air or on the ground, but the table and chair both must be on the ground, e.g on the lowest row.
############
#**********#
#**********#
#***$******|
#****TC****|
############

Also, you can assume that there is a wall behind any furniture, so a torch, chair or table can count as a separator between two holes.
############
#*    *    #
#*    *    #
#*    $    #
#**TC******|
############

The challenge
You must write the shortest function that takes a house as an ASCII string, and returns true/false whether or not it is valid housing. You can take this as a newline delimited string, a list of strings, or any other way as long as it is reasonable. For my sake, please include a short program so I can test if it works right or not.
For reference, these are all invalid inputs:
############
-**********#
-****$*****#
-**********#
-******TC**#
############  (You can't have platforms on the sidewalls)

###########-
#**********#
#**********#
#****$*****#
#**T***C***#
###########|  (NPC can't enter because the only entrances are on the corner)

############
#**********#
#******$***#
#**********#
#T****C****#
##--------##  (NPC has nowhere to stand)

############
#**********#
#**********#
#**********#
#**$**TC***#
##########|#  (Door cannot be in the floor or ceiling)

############
#**********#
#**********#
#**********#
|**   T C  #
############  (Since table and chair do not count as a background wall, the hole in background is too wide)

####### ####
#**********#
#**********#
#****$*****#
#**T***C***|
############  (There's a hole in the frame.)

###########################################################################
#                                                                         #
#                                                                         #
#                                                                         #
#                                                                         #
#                                                                         #
#                                                                         #
#                                                                         #
#                                                                         #
#                                                                         #
###########################################################################  (House is 75x11, which is too big.)

Leaderboard

var QUESTION_ID=68237,OVERRIDE_USER=31716;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Cool challenge, fellow Terraria lover.

Can we assume that holes will be rectangular? Otherwise this could use a test case where the whole does not fit in 4x4 but which never contains more than 4 spaces in a row.

There are many points which I find unclear. 1. Does the frame have to be rectangular? "all houses will be rectangles" suggests that they do, but doesn't clearly rule out frames which are non-rectangular but go into all four corners of their axis-aligned bounding box. And possibly holes can be surrounded by #. 2. As Martin asked, what exactly does "no holes can be larger than 4x4" mean? (Note also that it wasn't until my third read-through that I was certain of understanding what the hole was. You should write the spec for people who haven't played the game).

"This solid block cannot be directly adjacent to the walls" - what is a wall? From point 2 it seems to be *, but that would exclude the given examples of valid doors. 4. Does "on the ground" mean "in the penultimate row" or "above a #"? 5. "This does not apply to table and chairs." So does that mean that a 4x4 hole with a T or C directly below it is too big? 6. "NPC can't enter because the only entrances are on the corner" I don't think the spec said anything about the corners. May they be - or | if there are other doors?

If entrances on a corner are a problem because they don't admit access, does that mean that each * must be reachable from an entrance? Or are isolated * in the middle of holes allowed, holes which cut the entire room in two with only one side having an entrance allowed, and entrances which go directly into a hole allowed?

@PeterTaylor I think I clarified most of your questions, but I'll answer them here also. 1. Yes. If the frame is not a rectangle, the house is invalid. 2. If there is anywhere a row or column of 5 space characters in a row, that hole is larger than 4x4. 3. There is some ambiguity between "wall" as in frame and "wall" as in background wall. I tried fixing that. I meant they cannot be adjacent to the left or right sides of the frame. Test case #3 is a good example of this. 4. '#' will not be inside of the house, so it means In the penultimate row.

That rule seemed kind of pointless so I removed it. a T or a C functions as if there was a background wall behind it, just like a $. 6. I added the 'corner rule' to the spec. There may be a door or platform in the corner, as long as there is a valid entrance somewhere else. 7. I'm not sure if I understand this question. Isolated * are ok. Holes which cut the room in half are impossible, since * is a background wall, not a solid block. Entrances which go directly into a hole are also allowed.

Because it's not clear, could a door be above a space in a corner?

Or can a corner even be a space?

Can a door be in the living area of the house, or can I assume that will never happen?

@mbomb007 If any character along the outer grid is a space, the house is invalid. A door will not be in the living area.

Is that how it works in Terraria? I thought corners could be empty. huh

"Also, you can assume that there is a wall behind any furniture, so a torch, chair or table can count as a separator between two holes." This conflicts with the 3rd-to-last example of an invalid house. I'm going to assume that the example is wrong.

Python 2, 503 439 bytes
Not super short, but it's a solution. Let me know if you see something to golf. I'd recommend looking at my ungolfed version as well, since it's actually readable.
Edit: All the ifs outside a loop have been combined at the bottom.
def f(s):
 s=s.split("\n");e=l=0;h=len(s);w=len(s[0])
 for c in s[0][1:-1]+s[-1][1:-1]:
    if(c in"#-")<1:return 0
    if"-"==c:e=1
 for r in s[1:-1]:
    if(r[0]in"#|")*(r[-1]in"#|")<1or" "*5in r:return 0
    if"$"in r:l=1
 for r in zip(*s):
    if" "*5in`r`[2::5]:return 0
 if(h*w<60)+(h*w>749)+(w<5)+(h<4)or" "in s[0][0]+s[0][-1]+s[-1][0]+s[-1][-1]or("T"in s[-2])*("C"in s[-2])*l<1or("#"in s[-1][2:-2])<1or"|"in"".join(s[1:-1])<1>e:return 0
 return 1

Try it online
Ungolfed:
Also outputs the reason the result is False, for debugging purposes.
def f(s):

    # check dimensions
    s=s.split("\n")
    h=len(s)
    w=len(s[0])
    if h*w < 60 or h*w > 749 or w<5 or h<4: return False,"Size"

    # top / bottom
    e=0
    for c in s[0][1:-1]+s[-1][1:-1]:
        if(c in"#-")<1:return False,"T/B"

        # entrance
        if"-"==c:e=1

    # no spaces in corners -_-
    if" "in s[0][0]+s[0][-1]+s[-1][0]+s[-1][-1]: return False,"Corner"

    # light, table, chair
    l=t=c=0

    # left / right
    for r in s[1:-1]:
        if(r[0]in"#|")*(r[-1]in"#|")<1: return False,"L/R"

        # walls, put above
        if" "*5in r: return False,"Walls"

        # light
        if"$"in r:l=1

    # table, chair
    if"T"in s[-2]:t=1
    if"C"in s[-2]:c=1

    if l*t*c<1: return False,"L/T/C"

    # wall columns
    for r in zip(*s): # Transpose
        if" "*5in`r`[2::5]: # Tuple to string
            return False,"Walls"

    # entrance
    if"|"in"".join(s[1:-1])<1>e: return False,"Entrance"

    # place to stand
    if("#"in s[-1][2:-2])<1: return False,"Stand"

    return True

Ungolfed version online


text:
Convert a number to Hexadecimal
Challenge
Here's a simple one.
Write a function or program when given a number in base 10 as input, it will return or print that number's value in Hexadecimal.
Examples
15 -> F
1000 -> 3E8
256 -> 100

Rules

No built-in Hexadecimal functions whatsoever
Letters may be lowercase or uppercase
You will only need to worry about non-negative integers, no negatives or pesky decimals
It should work with any arbitrarily large number up to language's default type's limit.
Newline not mandatory
As usual, this is code-golf, so shortest code measured in bytes wins!

First problem, hope you guys enjoy!

Are leading zeros allowed in the output, e.g for 32bit numbers 000003E8?

Any limit on the input?

@Loovjo No, it should work for any arbitrarily large number.

@RandomGuy Even if it exceeds the language's default number type limit?

@nimi Yes, that is allowed.

@Loovjo No, then you can be safe.

@RandomGuy "No, it should work for any arbitrarily large number." ... please add this requirement to the challenge definition or drop it... having said this only in a comment sure will not be seen by everyone...

@yeti It is now fixed!

@RandomGuy ... "up to language's default type limit" ... aaaahhhh... now it reads mostly harmless ... ;-)

What about general base conversion built-ins, like APL's ⊤? In my answer I use APL's ⊥ which (among other usages) converts from other bases to base 10... Is that acceptable?

@NBZ I will allow conversions to other bases, yes.

Fun fact: C++ has a hex builtin.

In the exercise there is the phrase "•Newline not mandatory" this means that the number, or the hex characters that are printed have to end with '\n' a new line ?

APL (Dyalog APL), 17 bytes
Must be run with ⎕IO←0, which is default on many APL systems.
(⎕D,⎕A)[16⊥⍣¯1⊢⎕]

Try it online!
(⎕D,⎕A)[…] Digits concatenated to Alphabet, then indexed by…
 16⊥⍣¯1  the inverse of 16-Base-to-Number, i.e. Number-to-Base-16
 ⊢ applied to
 ⎕ numeric input

Isn't this 17 chars and around 23 bytes?

@JuliePelletier No, Dyalog APL uses its own 256 character codepage.

Oh!  Good to know.

Turing Machine Code, 412 bytes
As usual, I'm using the rule table syntax defined here. You can test it on that site or, alternatively, using this java implementation.
0 * * l B
B * * l C
C * 0 r D
D * * r E
E * * r A
A _ * l 1
A * * r *
1 0 9 l 1
1 1 0 l 2
1 2 1 l 2
1 3 2 l 2
1 4 3 l 2
1 5 4 l 2
1 6 5 l 2
1 7 6 l 2
1 8 7 l 2
1 9 8 l 2
1 _ * r Y
Y * * * X
X * _ r X
X _ _ * halt
2 * * l 2
2 _ _ l 3
3 * 1 r 4
3 1 2 r 4
3 2 3 r 4
3 3 4 r 4
3 4 5 r 4
3 5 6 r 4
3 6 7 r 4
3 7 8 r 4
3 8 9 r 4
3 9 A r 4
3 A B r 4
3 B C r 4
3 C D r 4
3 D E r 4
3 E F r 4
3 F 0 l 3
4 * * r 4
4 _ _ r A

Counts down from the input in base 10 while counting up from 0 in base 16. On decrementing zero, it erases the input block and terminates.

This is really cool, it takes 10*n + 33 instructions to complete for any arbitrary n. I don't understand the code though.

@MagicOctopusUrn It creates a new block of cells to the left of the input, initially containing a 0. Then, it repeatedly decrements the input block in base 10 while incrementing the output block in base 16, until it attempts to decrement an empty cell during the decrement cycle [which tells it that the input block is now 0], at which point it cleans up the tape (so only the output remains on the tape) before halting.

@MagicOctopusUrn Also your equation for the runtime is incorrect (I don't know what the correct general equation is though, just that that clearly isn't it). Try it with an input of 2, for example.

probably not. Seemed close for high values though. I know nothing about it and was attempting to see patterns.

Java, 92 89 bytes
String x(int v){String z="";for(;v>0;v/=16)z="0123456789ABCDEF".charAt(v%16)+z;return z;}

Javascript, 49 43 bytes.
h=i=>(i?h(i>>4):0)+"0123456789abcdef"[i%16]

6 bytes saved by user81655.
Test it here.
This has two leading zeroes, which is allowed by the rules.
Here's a version without leading zeroes: (47 bytes).
h=i=>(i>15?h(i>>4):"")+"0123456789abcdef"[i%16]

Test it here.
Both of these uses exactly the same approach as my Python answer.

Use binary AND. i&15 will automatically convert to integer, dropping decimals. No need of ~~

I saved 3 bytes and one leading zero: h=i=>i&&h(i>>4)+"0123456789abcdef"[i&15]

CJam, 22 21 bytes
ri{Gmd_A<70s=+\}h;]W%

Thanks to @MartinBüttner for golfing off 1 byte!
Try it online!
How it works
ri                      e# Read an integer from STDIN.
  {             }h      e# Do:
   Gmd                  e#   Push qotient and residue of the division by 16.
      _A<               e#   Check if the residue is less than 10.
         70s            e#   Push "70".
            =           e#   Select the character that corresponds to the Boolean.
             +          e#   Add the character to the digit.
                        e#   This way, 10 -> 'A', etc.
               \        e#   Swap the quotient on top of the stack.
                        e# While the quotient is non-zero, repeat the loop.
                  ;     e# Pop the last quotient.
                   ]W%  e# Reverse the stack.

Same byte count: ri{Gmd_9>7*sc+\}h;]W%

Pyth, 33 26 21 20 bytes
This was a fun one.
sm@+jkUTGi_d2_c_.BQ4

Try it online.
Explained:
                .BQ      Convert input to a binary string, e.g. 26 -> '11010'
             _c_   4     Reverse, chop into chunks of 4, and reverse again. We reverse
                         because chop gives a shorter last element, and we want a shorter
                         first element: ['1', '0101']
                         Reversing three times is still shorter than using .[d4 to pad the
                         binary string to a multiple of 4 with spaces.
 m                       Map across this list:
         i_d2                Take the value of the reversed string in binary,
  @                          and use it as an index into the string:
   +jkUTG                    '0123456789abcdefghijklmnopqrstuvwxyz'
                             (The alphabet appended to the range 0 to 10)
s                        Concatenate to create the final string.

Can you add an explanation?

Sure, which one are you interested in?

The most intersting answer! ;) it doesn't matter...Although it is a good idea to post explanations for all of them

Python, 59 58 bytes
h=lambda i:(i>15 and h(i/16)or'')+"0123456789abcdef"[i%16]

1 byte saved by CarpetPython
Run as: print h(15)
Test it here (Ideone.com).
Explanation:
h=lambda i:                                                 # Define h as a function that takes two arguments
           (i>15 and h(i/16)or'')                           # Evaluate h(i/16) if i > 15, else, give ''
                                 +"0123456789abcdef"[i%16]  # Append (i%16)'th hexadecimal number.

Nice work. You can also save another byte with h=lambda i:(i>15 and h(i/16)or'')+"0123456789abcdef"[i%16].

Nice work indeed, you can save another two like this: h=lambda i:(i>15 and h(i/16)or'')+chr(48+i%16+i%16/10*7)

Haskell, 59 58 43 41 39 bytes
s="0123456789ABCDEF"
(sequence(s<$s)!!)

Usage example: sequence(s<$s)!!) $ 1000 -> "00000000000003E8".
This creates a list of all hexadecimal numbers up to 16 hex-digits. Luckily this happens in order, so we can simply pick the nth one.
Edit: @Mauris squeezed out 2 bytes. Thanks!

Dat list monad doe

@Daenyth: I've switched from Monad to Functor

How about s="0123456789ABCDEF";(sequence(s<$s)!!)

@Mauris: awesome!

C (function), 51
Recursive function takes input integer as a parameter:
f(n){n>>4?f(n>>4):0;n&=15;n+=n>9?55:48;putchar(n);}

Test driver:
#include <stdio.h>

f(n){if(n>>4)f(n>>4);n&=15;n+=n<10?48:55;putchar(n);}

int main (int argc, char **argv) {

    f(15);puts("");
    f(1000);puts("");
    f(256);puts("");
    f(0);puts("");

    return 0;
}

dc, 37
?[16~rd0<m]dsmxk[A~r17*+48+Pz0<p]dspx

Recursively divmods by 16, pushing the remainder to the stack until nothing left to divide.  Then print each element of the stack, using divmod by 10 to achieve A-F digits.  Probably more detail tomorrow... (and hopefully less bytes).

C (gcc), 45 44 bytes
f(n){n&&f(n/16);n%=16;putchar(n+48+n/10*7);}

Try it online!

In the exercise there is the phrase "•Newline not mandatory" this means that the number has to end with '\n'?

Bash (function), 62
Thanks to @manatwork for suggesting using recursion.
h()(x=({0..9} {A..F})
echo `(($1>15))&&h $[$1/16]`${x[$1%16]})

Nice. But the recursive way still seems to be shorter: h(){ x=({0..9} {A..F});echo \(($1>15))&&h $[$1/16]`${x[$1%16]}; }`

@manatwork Nice - thanks!  For some reason I usually forget to try recursion in bash, even though I'm using it in other answers.  Using () instead of { ;} around the function body saves even more :)

Perl 6,  53  48 bytes
{[R~] (0..9,'A'..'F').flat[($_,*div 16...^0)X%16]||0}
{[R~] (0..9,'A'..'F').flat[.polymod(16 xx*)]||0}
This creates a sequence of values that are Integer divided (div), until the result is 0 excluding the 0 from the sequence
$_, * div 16 ...^ 0

It then crosses (X) that sequence using the modulus operator (%) with 16
( … ) X[%] 16

It uses those values as indexes into a flattened list consisting of two Ranges 0..9 and 'A'..'Z'
( 0 .. 9, 'A' .. 'Z' ).flat[ … ]

Finally it concatenates (~) them using the reverse (R) meta operator
[R[~]] …

If that results in a False value (empty string), return 0
… || 0

Usage:
# (optional) give it a lexical name for ease of use
my &code = { … }

say <15 1000 256 0>.map: &code;
# (F 3E8 100 0)

say code 10¹⁰⁰;
# 1249AD2594C37CEB0B2784C4CE0BF38ACE408E211A7CAAB24308A82E8F10000000000000000000000000

MATL, 27 bytes
i`16H#\wt9>?7+]wt]xN$hP48+c

This uses release 5.1.0 of the language/compiler, which is earlier than this challenge.
Example
>> matl
 > i`16H#\wt9>?7+]wt]xN$hP48+c
 >
> 1000
3E8

Explanation
i              % input number
`              % do...
  16H#\        % remainder and quotient of division by 16
  w            % move remainder to top of stack
  t9>          % does it exceed 9?
  ?            % if so
    7+         % add 7 (for letter ASCII code)
  ]            % end if
  w            % move quotient back to the top
  t            % duplicate
]              % ...while (duplicated) quotient is not zero
x              % delete last quotient (zero)
N$h            % create vector of all remainders
P              % flip vector
48+c           % add 48 and convert to char (will be implicitly displayed)

, 31 chars / 62 bytes
↺a=⬯;ï;ï≫4@a=⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝[ï%Ḑ]+a

Try it here (Firefox only).
Okay, I figured out some more stuff that golfed it down.
Explanation
It's essentially the same solution as @SuperJedi224's ES6 solution - but with something different.
See ⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝? That's a really fancy way of writing "0123456789ABCDEF". ⩥Ḋ creates a range from 0 to 10, Ⓒª⩥⁽ṁṇ⸩ creates a range from 65 to 71 and converts it to a string of ASCII, and Ā...⨝ concatenates the two ranges and joins them into one string. This was probably the coolest part of my solution.
Bonus non-competitive version, 24 chars / 45 bytes
↺;ï;ï≫4@ᵴ=(⩥Ḋ⨝+ᶐ)[ï%Ḑ]+ᵴ

I decided to add an alphabet string, like in Pyth.

sed, 341 bytes
:
s/\b/_/2
s/[13579]/&;/g
y/123456789/011223344/
s/;0/5/g
s/;1/6/g
s/;2/7/g
s/;3/8/g
s/;4/9/g
s/;_;_;_;_/=/
s/;_;_;__/+/
s/;_;__;_/:/
s/;_;___/>/
s/;__;_;_/</
s/;__;__/?/
s/;___;_/(/
s/;____/*/
s/_;_;_;_/-/
s/_;_;__/^/
s/_;__;_/%/
s/_;___/$/
s/__;_;_/#/
s/__;__/@/
s/___;_/!/
s/____/)/
/[1-9_]/b
y/)!@#$%^-*(?<>:+=/0123456789ABCDEF/
s/^0*//

It's not the obvious language for this challenge, but it does have the advantage of supporting input numbers up to (depending on your implementation) between 4000 digits and the limit of your system's available (virtual) memory.  I converted RSA-1024 to hex in about 0.6 seconds, so it scales reasonably well.
It works using successive division by two, accumulating every 4 bits of carry into a hex digit.  We use non-letter characters to represent our output, so that we always accumulate carry between the decimal input and the hex output, and convert to conventional hexadecimal at the very end.

PHP, 65 66 64+1 62 59 bytes
function h($n){$n&&h($n>>4);echo"0123456789abcdef"[$n&15];}

recursive printing function, prints a leading zero (insert >16 before && to remove it)

programs, 64 bytes +1 for -R (run as pipe with -nR)
for(;$n=&$argn;$n>>=4)$s="0123456789abcdef"[$n&15].$s;echo$s?:0;

requires PHP 5.6 or later (5.5 cannot index string literals)
or
for(;$n=&$argn;$n>>=4)$s=(abcdef[$n%16-10]?:$n%16).$s;echo$s?:0;

requires PHP 5.6 or 7.0 (7.1 understands negative string indexes)

Run as pipe with -nR or try them online.

I am missing a plus sign echo+$s for input 0

+ sign cuts the output at the first letter ... so .. ?:0

Javascript ES6, 64 58 bytes
v=>eval('for(z="";v;v>>=4)z="0123456789ABCDEF"[v%16]+z')

Saved 6 bytes thanks to ןnɟuɐɯɹɐןoɯ and user81655.

Use eval: v=>eval('for(z="";v;v=v/16|0)z="0123456789ABCDEF"[v%16]+z')

Oh yeah, try using atob and btoa for that long string.

@ןnɟuɐɯɹɐןoɯ Tried v=>{for(z="";v>0;v=v/16|0)z=btoa``Ó]·ã»óÐ1``[v%16]+z;return z} (The double tildes are single tildes) ==> 64 chars, 71 bytes.  Not worth it.

v=v/16|0 is just a complex way of writing v>>=4.

Julia, 55 bytes
h(n)=(n>15?h(n÷16):"")"0123456789ABCDEF"[(i=n%16+1):i]

This is the basic recursive function implementation. It accepts an integer and returns a string.
If the input is less than 15, floor divide it by 16 and recurse, otherwise take the empty string. Tack this onto the front of the appropriately selected hexadecimal character.

Pyre, 98 bytes
Doing this in a language without arithmetic operators was probably a mistake.
let h=def (n)(if n.gt(15)h(n.div(16).int!)else "").concat("0123456789abcdef".list!.get(n.mod(16)))

Use like this:
do
  let h = ...
  print(h(15))
end

Ungolfed:
let h = def (n) do
    if n.gt(15)
        let x = h(n.div(16).int!)
    else
        let x = ""
    x.concat("0123456789abcdef".list!.get(n.mod(16)))
end

Ruby, 48 characters
(Copy of Loovjo's Python answer.)
h=->n{(n>15?h[n/16]:'')+[*?0..?9,*?a..?f][n%16]}

Sample run:
2.1.5 :001 > h=->n{(n>15?h[n/16]:'')+[*?0..?9,*?a..?f][n%16]}
 => #<Proc:0x00000001404a38@(irb):1 (lambda)>
2.1.5 :002 > h[15]
 => "f"
2.1.5 :003 > h[1000]
 => "3e8"
2.1.5 :004 > h[256]
 => "100"

Befunge-93, 58
&:88+%"0"+:"9"`7*+\8/2/:!#|_#
,_@                       >:#

First time doing a real golfing challenge in Befunge, I bet there's a one-liner for this that's shorter since all those spaces in the middle of the second line seem wasteful.
You can step through it here. Partial explanation:
&: Take input.
:88+%: Take the remainder modulo 16.
"0"+: Add it to the ASCII value of 0.
:"9"`: If the result is greater than the ASCII value of 9...
7*+: Add 7 to convert it to a letter.
\: Save the resulting character on the stack.
8/2/: Divide by 16 rounding down.
:!#|_: Exit the loop if the result is 0.
#: Otherwise go back to the modulus step.
>:#,_@ (wrapping around): Once finished, output the stack in LIFO order.

Seriously, 35 bytes
,`;4ª@%)4ª@\`╬Xε D`@;7ªD+@9<7*+c+`n

Hex Dump:
2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e

Try It Online
Explanation:
,                                    Get evaluated input
 `          `╬                       Repeat the quoted function until top of stack is 0
  ;4ª@%                              Make a copy of the number mod 16
       )                             Send it to bottom of stack
        4ª@\                         Integer divide the original copy by 16
              X                      Delete the leftover zero. At this point the stack is
                                     the "digits" of the hex number from LSD to MSD
               ε                     Push empty string
                 D`              `n  Essentially fold the quoted function over the stack.
                   @;                Roll up the next lowest digit, make a copy
                     7ªD+            Add 48
                         @           Bring up the other copy
                          9<         1 if it's at least 10, else 0
                            7*       Multiply with 7.
                              +      Add. This will shift 58->65 and so on.
                               c     Convert to character.
                                +    Prepend to current string.

Note that the ;7ªD+@9<7*+c is equivalent to 4ª▀E, which would save 8 bytes, but I thought that perhaps a function that pushes the base b digits as a string might be considered too much of a "heaxadecimal built-in".

><>, 46 + 3 = 49 bytes
This would have been shorter if ><> had integer division, which we now have to emulate by subtracting modulo 1. Still, I think this uses some pretty neat wrapping around tricks!
>:?!v:f1+%:a(?v  v
\-%1:,+1f}+"0"<+7<
!?:r/ro;

Try it online!
Explanation
First loop
>:?!v:f1+%:a(?v  v
\-%1:,+1f}+"0"<+7<

The first loop performs the classic converting to hex
algorithm. It does modulo 16 (:f1+%) and checks if
the result is < 10 (:a(?). If it's not, we need to add
7 (7+) in order to go from the decimals to the capital alphabet
in the ASCII table. Else, we can proceed by adding the ASCII
value for 0 ("0"+) and shifting the character to be output
to the bottom of the stack because we'll have to output them
in reverse order. The top value is then replaced by its result
of integer division by 16. This is emulated by computing
a/b - (a/b)%1 (f1+,:1%-). When the loop is finished, the stack contains the hexadecimal characters in reversed output order and a 0.
Second loop
!?:r<ro;

The second loop reverses the list and checks if top element is 0.
If it is, we know all nonzero were printed and we should terminate.
Else, we output the character and reverse the list again to prepare
for the next iteration. The : when entering the second loop will duplicate the 0 which has no effect.

SpecBAS - 110 bytes
1 h$="0123456789ABCDEF",r$=""
2 INPUT d
4 q=INT(d/16),r=d-(q*16),r$=h$(r+1)+r$,d=q
5 IF q>15 THEN 4
6  ?h$(q+1)+r$

This uses an algorithm I found on WikiHow (2nd method).
Strings in SpecBAS are 1-based, hence the +1 to pick out the correct element.

C (clang), 83 bytes
f(n){char h[8]={0};int i=8;while(i>0){h[i-1]=n%16;n/=16;printf("%x",h[8-i]);i--;}}

Try it online!
Alternate solution in C

Ruby, 40 bytes
Stolen from Inspired by manatwork's answer, but using an interesting loophole to make it shorter.
h=->n{(n>15?h[n/16]:'')+(n%16).to_s(17)}

REXX, 80 78 bytes
arg n
h=
do while n>0
  h=substr('0123456789ABCDEF',n//16+1,1)h
  n=n%16
  end
say h

C, 48 bytes
h(x){x/16&&h(x/16);x%=16;putchar(x+=48+x/10*7);}

This is not completely original, I shaved 5 bytes off of the version Digital Trauma put up.

APL(NARS), chars 34, bytes 68
{⍵≤0:,'0'⋄(∇⌊⍵÷16),(1+16∣⍵)⊃⎕D,⎕A}

test:
  g←{⍵≤0:,'0'⋄(∇⌊⍵÷16),(1+16∣⍵)⊃⎕D,⎕A}
  g 0
0
  g 100
064
  g 1000
03E8
  g 1
01

Charcoal, 25 bytes
Ｎθ≔⁺⭆χι…α⁶ηＰ0Ｗθ«←§ηθ≧÷¹⁶θ

Try it online! Link is to verbose version of code. Explanation:
Ｎθ

Input the number.
≔⁺⭆χι…α⁶η

Create the string of hexadecimal digits by joining the range 0..9 with the first six letters.
Ｐ0

Output a zero in case the input is zero.
Ｗθ«

Repeat while the number is nonzero.
←§ηθ

Cyclically index into the hex digits and move the cursor to the left after printing.
≧÷¹⁶θ

Integer divide the number by 16.

Retina 0.8.2, 56 bytes
.+
$*#;
+`(#+)\1{15}
$1;
(#{10})?(#*);
$1$.2
T`#d`_L`#+.

Try it online! Link includes test cases. Retina doesn't actually have a built-in for this anyway. Explanation:
.+
$*#;

Convert the input to unary using #s and append a ;.
+`(#+)\1{15}
$1;

Keep trying to divide the input by 16, leaving the remainder after another ;.
(#{10})?(#*);
$1$.2

Convert each remainder to base 10, but if it's 10 or more, then just convert the last digit, leaving the 10 #s behind.
T`#d`_L`#+.

Change the digits after #s from 0-5 to A-F and delete the #s.


text:
Follow the path
The challenge is to follow (draw) the path:

^n - up by n lines
vn - down by n lines
>n - right by n character positions
<n - left by n characters positions

n is an integer, greater than zero (i.e. you can't receive a command like >-2).
There're no separators between the commands, the well-formed input looks like this: >5v8<10^3, no other form of input allowed.
The number of commands is unlimited.
No more characters are supposed to creep into the input.

Examples.

Input is an empty string, output:
*

Input is either >3 or <3: note that this doesn't make any difference to the output:
****

Similar for ^3 and v3:
*
*
*
*

Input: >1v2, output:
**
 *
 *

Input: ^4>3v2<1, output:
****
*  *
* **
*
*

If you go back and use the same path, don't draw anything new. E.g. >5<5
******

...though you don't draw anything new, you obviously change the position. Hence, if your input looks like this: >4<2v3, the output is:
*****
  *
  *
  *

This is a more complex example: 1) the path can cross itself 2) note that the last three steps of the last command shift the whole path to the right. Input: v6>4^3<7, output:
   *
   *
   *
********
   *   *
   *   *
   *****

Input:
^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1

Output:
*   *  *****  *****  *****  *   *     *** *  ******  *     *    *   *  ******  *****  *****
*   *  *   *  *   *  *   *  *   *     * * *  *       *  *  *    *   *  *       *   *  *   *
*****  *****  *****  *****  *****     * * *  ******  ** * **    *****  ******  *****  *****
*   *  *   *  *      *        *       * * *  *        * * *       *    *       *   *  **
*   *  *   *  *      *        *       * ***  ******   *****       *    ******  *   *  *  **
*******************************************************************************************

As you have posted this challenge today, I think this will be a proper test case: ^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1.

Could you possibly provide a reference implementation?

Isn't that actually a dupe though? Please decide :D

@nicael: I'd say it isn't; the I/O is different, and it seems paths can't cross in the other one. I think this one is simpler in ways that could allow different golfing strategies. However, I wasn't aware I was suddenly able to reopen these all by myself, I thought I was merely casting a vote.

@marinus Ok then. So, related: Yarr! A map to the hidden treasure!.

@Legion I could maybe do it, though often the implementation is thought through by the answerers.

The only important difference is that here (sensibly) yuo have to move, then mark. In the other challenge it was the opposite

MATL, 71 bytes
1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c

Uses current release (6.0.0) of the language/compiler. Works in Matlab and in Octave.
EDIT (June 21, 2016): due to changes in the language, the code requires a few modifications to run in current release (16.0.0). You can try it online including the needed modifications.
Examples
>> matl
 > 1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c
 >
> ^4>3v2<1
    ****
    *  *
    * **
    *
    *

>> matl
 > 1thj'.\d+'XX"@Z)XK6L)U:"K1)XK118=K94=-K62=K60=-hv]]YstY)X<1--lqg10*32+c
 >
> ^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1
  *   *  *****  *****  *****  *   *     *** *  ******  *     *    *   *  ******  *****  *****
  *   *  *   *  *   *  *   *  *   *     * * *  *       *  *  *    *   *  *       *   *  *   *
  *****  *****  *****  *****  *****     * * *  ******  ** * **    *****  ******  *****  *****
  *   *  *   *  *      *        *       * * *  *        * * *       *    *       *   *  **
  *   *  *   *  *      *        *       * ***  ******   *****       *    ******  *   *  *  **
  *******************************************************************************************

Explanation
The program has four main steps:

Read input string and split into its components.
Build a 2-column matrix where each row describes a unit displacement in the appropriate direction. For example, [0 -1] indicates one step to the left. The first row is the origin of the path, [1 1]
Compute the cumulative sum of that matrix along the first dimension . Now each row describes the coordinates of a *. Normalize to minumum value 1
Create a new matrix that contains 1 at the coordinates indicated by the matrix from step 3, and 0 otherwise. This is then transformed into a char matrix.

Code:
1th                         % row vector [1 1]. Initiallize matrix of step 2
j                           % (step 1) read input string
'.\d+'XX                    % split into components. Creates cell array of substrings
"                           % (step 2) for each component
   @Z)XK                    % unbox to obtain substring and copy
   6L)U:                    % obtain number and build vector of that size
   "                        % repeat as many times as that number
      K1)                   % paste substring. Get first character: '^', 'v', '>', '<'
      XK118=K94=-           % vertical component of unit displacement: -1, 0 or 1
      K62=K60=-             % horizontal component of unit displacement: -1, 0 or 1
      h                     % concatenate horizontally
      v                     % append vertically to existing matrix
   ]                        % end
]                           % end
Ys                          % (step 3) cumulative sum along first dimension
tY)X<1--                    % normalize to minimum value 1
lqg                         % (step 4) build matrix with 0/1
10*32+c                     % replace 0 by space and 1 by asterisk

Does it work for the last example?

How nice! Yes, it does. I have edited my answer to include it

JavaScript (ES6), 204 211 210
Edit 1 Bug fix - output '*' for void input
Edit 2 Simpler decoding of direction to x and y diff
Here is my answer to The treasure map, revised to fulfill the specs.
F=m=>(m.replace(/\D(\d+)/g,(d,z)=>{for(;z--;r=[...r],r[x]=m,p[y]=r.join``)for(d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,p=~x?~y?p:[y=0,...p]:p.map(r=>' '+r,x=0),r=p[y]||'';!r[x];)r+=' '},x=y=0,p=[m='*']),p.join`
`)

Less golfed and explained more or less
f=m=>(
  x=y=0, // starting position
  p=['*'], // output string array (initialized with minimum output)
  m.replace( /\D(\d+)/g,
  (d,z) => // execute the following for each group direction/length. Length in z, direction in d[0]
  {
    while( z--)  // repeat for the len
    {
      // check d to change values of x and y
      // all the comparison are with > and <, not equal
      // so that they work with the whole d, not just d[0]
      d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,
      // now if x or y are < 0 then p must be adjusted
      p = ~x
        ? ~y
          ? p // both x and y are >= 0, p is not changed
          : [y = 0, ...p] // y < 0, shift p by on adding a 0 element and set y to 0
        : p.map(r=> ' ' + r, x = 0); // x < 0, add a space to the left for each row in p and set x to 0
      r = p[y] || ''; // get current row in r
      for( ; !r[x]; ) // if the current row is empty or too short
        r += ' '; // ... add spaces up to position x
      // set character in x position
      r = [...r], // the shorter way is converting to array ...
      r[x] = '*', // setting the element
      p[y] = r.join`` // and the back to string using join
    }
  }),
  p.join`\n` // return output array as a newline separated string
}

Test

F=m=>(m.replace(/\D(\d+)/g,(d,z)=>{for(;z--;r=[...r],r[x]='*',p[y]=r.join``)for(d<'>'?--x:d<'^'?++x:d<'v'?--y:++y,p=~x?~y?p:[y=0,...p]:p.map(r=>' '+r,x=0),r=p[y]||'';!r[x];)r+=' '},x=y=0,p=['*']),p.join`
`)

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

console.log(F('')+'\n')

console.log(F('v6>4^3<7')+'\n')

console.log(F('^2v2>3<3v3>4^5v5>3^5>4v2<4v3>4^3v3>3^5>4v2<4v3>7^5>4v2<4v3>9^3<2^2v2>4^2v2<2v3>8^5>2v4>2^4v5<3>6^5>5<5v2>5<5v2>5<4v1>8^3<1^2v2>1v2>2^3v3>2^2>1^2v2<1v3<3>11^3<2^2v2>4^2v2<2v3>5^5>5<5v2>5<5v2>5<4v1>7^5>4v2<4v3>4^3v3>3^5>4v2<3v1<1v2>3^1>1v1'))

Seems to work perfectly.

With one only exception: when the input is empty, the requirement is to write *.

To ones who's browsers are having problems with interpreting ES6: https://jsfiddle.net/2vrrd1wt/.

@nicael thanks for noticing. Fixed for 1 byte

Perl, 174 bytes
@M=(['*']);pop=~s/(.)(\d+)/($z=ord$1)&64?($y+=$z&8?-1:1)<0&&unshift@M,[$y++]:($x+=($z&2)-1)<0?@M=map{[$x=0,@$_]}@M:0,$M[$y][$x]='*'for1..$2/gre;print map{map{$_||$"}@$_,$/}@M

Expects input as commandline argument. Be sure to quote the argument!Example: perl 177.pl "<1^2>3v4<5^6>7v8<9^10>11"
Somewhat readable:
@M=(['*']);                                 # output origin/starting position

pop=~                                       # apply regex to cmdline arg
s!(.)(\d+)!                                 # match $1=direction, $2=count

    ($z=ord$1)                              # get ASCII code for char
    &64                                     # 'v^' have this bit set, '<>' don't

        ?                                   # adjust y:
            ($y += $z&8 ? -1 : 1)           # '^' has bit set, 'v' doesn't
            < 0 &&                          # negative y?
            unshift @M, [$y++]              # prepend row; abuse [] for $y++ saving 3 bytes

        :                                   # adjust x:
            ($x+= ($z&2) -1 )               # '>' has bit set: 2-1=1, '<' hasn't: 0-1=-1
            < 0 ?                           # negative x?
                @M = map{ [$x=0,@$_] } @M   # prepend column, reset x
                :0                          # '?:0' shorter than '&&()'
        ,                                   # oh, and also:
        $M[$y][$x]='*'                      # output current position.

    for 1..$2                               # iterate count
!grex;

print map{ map{$_||$"} @$_, $/ } @M         # iterate rows/cols, print '*' or space

Vyxal ?, 197 bitsv2, 24.625 bytes
kdFf`^>v<`kd√Ŀ?f⌊0€Ḣṅ⌊›×?[ø^

Try it Online!
Bitstring:
10000000000001110010111101000000110111011010110000000000100001111110101111001000101011110011001101001000011000101100010101000011110111000110001011100110000011001111111111010010100100111110001000000

kdFf`^>v<`kd√Ŀ?f⌊0€Ḣṅ⌊›×?[ø^
kdFf                          # remove all digits from input and flatten
                              # to give list of directions
    `^>v<`                    # arrows in canvas directions
          kd√                 # even digits (02468)
             Ŀ                # transliterate directions to corresponding canvas directional number (ignores the 8) [1]
              ?f⌊             # flatten the input and get the numbers
                 0€Ḣ          # split on 0 and remove the first element (always an empty list due to input format)
                    ṅ⌊        # join sublists by nothing and convert to number(deals with multi digit numbers)
                      ›       # increment (no idea why i need this but the entire program breaks without it) [2]
                       ×      # literal "*"
                        ?[    # if the input is true
                          ø^  # draw on the canvas using directions defined in [1] lengths defined in [2] and printing the text as "*"
# otherwise, implicitly print "*"

Created with the help of Luminespire.

05AB1E, 27 bytes
">^v<"žCÍS1ú‡#¦εć)>}ø`'*s<Λ

Try it online! (2020 is close enough so why not)


text:
Build an image-glitching algorithm
It's well known that corrupted JPEG files or NTSC/PAL streams will appear as distorted versions of the true images, or versions covered in random-looking blocks of pixels.

Consider the below image (from here):

If we run it through this filter (with settings 44, 7, 21, 83, for anyone who wants to reproduce it), it ends up looking like this:

Your task is to build a program that takes the pixels of a given image and mutilate it in some way to make it look like a computer processing error like above.
Your program will take an uncompressed bitmap file (in the format of your choice) and return a "glitched" file of the same uncompressed format.
Your program may not make any use of existing image processing libraries. (This is to make sure that the algorithm does not simply flip a few bytes in the file and let the image decompressor do the rest, like JPEG glitch programs usually do.)
Your program must also visibly transform existing pixels, rather than simply overlaying noise on the picture.
As this is a popularity contest, the program with the highest votes is the winner.

Too broad? How could I make it more specific?

I don't think it's perfectly clear what counts as a "glitched" image, popularity-contests should still have a specific spec to avoid loopholes, etc.

True. I'll think about it a little more.


text:
Waiting for 2016
Task
Constantly having to check on television, or the time on your computer to see if its 2016 is a tedious task. Being programmers, we should be able to automate this task. Write a program that will output 2016 when the system time hits Friday, January 01, 2016 00:00:00. or rather 1451624400000 ms since midnight January 1, 1970.
Input
There will be no input to your program.
Output
Your program will output 2016 to STDOUT or the equivalent when the system time hits 1451624400000. The maximum allowed delay is 1 second or 1000 ms. If your program is started after 1451624400000, it should not output anything (an empty string is fine) and terminate normally.
Rules

Your code must be a full program, not just a function.
You can assume your program will be started after midnight January 1, 1970.
Your program should be able to detect 2016 within a second of it occurring.
Your program should terminate after outputting 2016.
If your program is started after midnight January 1, 2016, it should not produce any output, or an empty string, and should terminate normally.

Scoring
To keep with the trend of shortcomings in 2015, this is a code-golf challenge. The shortest code in bytes wins.

Many of Legen… wait for it… and Is it Christmas? solutions seems to be reusable here...

I was actually looking at the Legen… wait for it… challenge. The reason I didn't consider this a duplicate is that this one is easier in that you can hard code the date you're waiting for, so that'll hope allow shortcuts in the code, and also, there isn't a guaranteed output if your code starts after 2016.

So when the program is run prior to 2016-01-01, it should wait until 2016 then print and exit? That is, if this were to hypothetically be run in 1986, it would have to continue to run for 30 years?

Yes, that's right. If it run anytime after Jan 1, 1970 and before Jan 1, 2016, it should run until midnight Jan 1, 2016, print 2016 and then exit

Pyth, 20 17 bytes
WnJ2016.d3=hZ)IZJ

This is rather simple.

J2016: assign J = 2016
.d3: gets current year
WnJ2016.d3: while current year is not 2016
=hZ: increment Z, which starts at 0
): end the loop
IZJ: print J (2016) if Z is not zero, i.e. the loop was run at least once

An alternative to 2016: C\ߠ

@LegionMammal978 One character less, but would take more bytes. Also, Pyth uses ISO-8859-1.

ߠ uses 2 bytes, so it would cancel out.

@LegionMammal978 Yeah, but then 2016 is still more readable. Also I don't think you can do ߠ in ISO-8859-1

It works on the online interpreter for me.

Mathematica, 53 49 bytes
a:=UnixTime[]<1451606400;If[a,While@a;Print@2016]

Not entirely sure if it works. Will have to wait for another 9 hours...

LOL and what... just imagine... WHAT if it doesn't work?? :O

You can change the date on your computer. Also, you can come to Finland where it's only 2 more hours ;-)


text:
Can a fraction be simplified using Anomalous Cancellation?
Anomalous Cancellation (from Wolfram Alpha):

Anomalous cancellation is a "canceling" of digits of a and b in the numerator and denominator of a fraction a/b which results in a fraction equal to the original. Note that if there are multiple but differering counts of one or more digits in the numerator and denominator there is ambiguity about which digits to cancel, so it is simplest to exclude such cases from consideration.
  Link

In simple terms, say you have a fraction a / b. If you can cancel out the digits in the fraction to create another fraction c / d which is equal to the original (a / b = c / d), anomalous cancellation can be used to simplify the fraction.
Your challenge is to make a program or function that inputs a fraction string in the form a/b and outputs or returns a truthy value if the fraction can be simplified using anomalous cancellation, and a falsy value otherwise. a and b will always be non-zero positive integers. a and b will always have two or more digits. Also, all of the digits from either a or b will not be cancelled out (You wont get the input 12/21), at least one digit from a and b will be cancelled each time (You wont get the input 43/21), and the end result will never be 0 for either a or b. Your program must cancel out all common digits between a and b (ie. in 1231/1234, you must cancel out a 1, a 2, and a 3). If there is multiple possibilities for cancellation, choose the leftmost digit first (515/25 becomes 15/2 not 51/2).
Examples:
Input      Output    Why

1019/5095  true      Remove the 0 and the 9 from both sides of the fraction to get 11/55, which is equivalent.
16/64      true      Remove the 6 from both sides, and get 1/4.
14/456     false     Remove the 4s. 14/456 is not equal to 1/56.
1234/4329  false     Remove the 2s, 3s, and 4s. 1234/4329 is not equal to 1/9.
515/25     false     Remove the first 5 from each side. 15/2 is not equal to 515/25.

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

Relaticate: http://codegolf.stackexchange.com/questions/37794/how-not-to-reduce-fractions Coincidentally I have just brosed the exact mathworld entry you're citing=)

I was under impression 515/25 cancels to 103/5?

@Pulga The first 5 in the numerator will cancel with the 5 in the denominator, leaving 15/2.

@Pulga 11 and 55 do not share any digits, so it cannot be simplified more using this method. However, using normal fraction simplifying, this would be the case, but in this challenge we are only cancelling digits.

What is the answer for 43/21?

@xnor I just clarified this in the question. Input such as that will not be given. At least one digit will be cancelled each time.

Will you get 19/10? What would it output?

@BlockCoder1392 Not valid input. Added to challenge.

Perhaps add a bonus for instead outputting which digit(s) should be removed? Could be interesting.

Pyth, 22 19 bytes
Thanks to @isaacg for three bytes!
qFcMsMM,Jcz\/.-M_BJ

Explanation:
qFcMsMM,Jcz\/.-M_BJ      Implicit: z=input().
       ,                 two-element list
        Jcz\/              J = split z on ','
                _BJ      Bifurcate reverse: [J,reversed(J)]
             .-M         map multiset difference of elements in both lists
                             this gives the multiset difference both ways
       ,Jcz\/.-M_BJ      On input 1019/5095: [['1019','5095'], ['11','55']]
    sMM                  convert all strings to numbers
  cM                     map by float division
qF                       fold equality

Try it here.

m.-Fd can be golfed to .-M. Likewise, mcFsMd can be golfed to cMsMM.

@isaacg Interesting; I was wondering why .-FM didn't work. So M automatically splats on non-monadic functions?

, 17 chars / 34 bytes
ïČ⍘/⎖0ⓢⓈë(ïę$)≔ëï

Try it here (Firefox only).
Explanation
ïČ⍘/⎖0ⓢⓈë(ïę$)≔ëï // implicit: ï = input fraction
ïČ⍘/⎖0              // get the numerator...
      ⓢ            // split it...
        Ⓢ          // and check if any of its items satisfy the condition:
          ë(ïę$)    // When the item is removed from ï,
                ≔ëï // does its fractional value still equal the original fractional value?
                    // implicit output

I've been around  for two months now, and it still looks like magic to me. +1

Ruby, 95 76 bytes
->a{x,y=a.split(?/).map &:chars;eval a+".0=="+(x-y).join+?/+(y-x).join+".0"}

Explanation
->a{                                                    # start of lambda
      a.split(?/)                                       # splits input fraction into numerator and denominator
                 .map &:chars;                          # converts them both into arrays of digits
  x,y=                                                  # assigns the numerator to x and the denominator to y

  eval                                                  # Evaluate...
       a+".0                                            # Original fraction with a .0 attached -- this forces floating-point division
            =="                                         # Equals...
               +(x-y).join                              # Numerator: Takes the relative complement of y in x (all elements in x that are not in y) and joins the resulting array into a string
                          +?/+(y-x).join                # Denominator: Takes the relative complement of x in y and joins the resulting array
                                        +".0"           # Add a .0 to force floating-point division
}

Massive thanks to Doorknob for golfing 19 bytes off.

TeaScript, 22 bytes
xs`/`[0]M#E(xg(l))⌐E(x

Now that all the bugs are ironed out in TeaScript 3, this works nicely
Try it online
Test suite

I get E is not defined.

@ןnɟuɐɯɹɐןoɯ huh, weird, it worked from Github... Updating...

Great, it works fine now!

Javascript ES6, 73 bytes
a=>[...a.split`/`[0]].some(x=>(e=eval)(a.replace(e(`/${x}/g`),``))==e(a))

MATL, 35 bytes
jtXUw'\d+'XXZ)2$XKtbm~)Kwtbm~)UwU/=

Examples
>> matl
 > jtXUw'\d+'XXZ)2$XKtbm~)Kwtbm~)UwU/=
 >
> 1019/5095
1

>> matl
 > jtXUw'\d+'XXZ)2$XKtbm~)Kwtbm~)UwU/=
 >
> 14/456
0

Explanation
j              % input string
tXUw           % duplicate, convert to number, swap
'\d+'XX        % apply regexp to split at '/'
Z)             % separate cell array of strings into two strings
2$XK           % copy those two strings to clipboard K
tbm~)          % remove from denominator all chars present in the numerator
Kw             % paste both strings and swap
tbm~)          % remove from numerator all chars present in the denoninator
UwU/=          % obtain value of "simplified" fraction and compare with original