text:
Numbers that are actually letters
Given a non-negative integer input, write a program that converts the number to hexadecimal and returns a truthy value if the hexadecimal form of the number contains only the characters A through F and a falsey value otherwise.

Test cases
10
==> True (A in hexadecimal)

100
==> False (64 in hexadecimal)

161
==> False (A1 in hexadecimal)

11259375
==> True (ABCDEF in hexadecimal)

0
==> False (0 in hexadecimal)

Bonus: -40 bytes if your program prints Only letters for the challenge described above, Only numbers if the hexadecimal version of the number only contains the digits 0-9 and Mix if the hexadecimal number contains at least one number and at least one letter.

This is code golf. Standard rules apply. Shortest code in bytes wins. Either functions or full programs are allowed.

Currently drafting an answer in Golfical.

My current idea: covert to base 16 string, then See if trying to parse that string as a base 10 number returns NaN

@Cyoce That may work, depending on your choice of language

Unrealistic bonus (once again): just the string MixOnlynumbersletters is 21 chars

Never mind, a1 can't be parsed as base 10 either.

You say "positive integer input", but 0 is a test case.

@edc65 Pyth (and I) say otherwise.

@isaacg Pyth (and you) would have been at ease with the original -25 bonus (which I was referring to)? WIth a score of 18 instead of Adnan's 6

@edc65 Thanks, I didn't realise the original bonus was lower.

@SuperJedi224 Have you come up with a solution? Or have you already posted it and I missed it?

@Ampora Sorry about that. I kind of forgot.

Pyth, 43 - 40 = 3 bytes
?&K@J.HQG-JG"Mix"%"Only %sers"?K"lett""numb

Test suite
This achieves the bonus. Only numbers and Only letters fortunately only differ by 4 letters. printf-style formatting is used with %.
The selection system is done by both taking the intersection of the hex with G, the alphabet, and subtracting out G. If neither ends up falsy, it's a mix, while if the intersection is falsy, it's numbers, and if the subtraction is falsy, it's letters.

Damn this Pyth is weird. Would be very cool if you could get a negative score though.

Pyth, 6 bytes
!-.HQG

  .HQ   # Converts the input to hexadecimal
 -   G  # Deletes all letters
!       # If empty, output True, else False

Test it here

Python, 24 bytes
lambda n:min('%x'%n)>'9'

Converts the input a hex string (without 0x prefix) with '%x'%n. Sees if all its chars are greater than '9' (which letters are) by seeing if the min is above '9'.

I don't know how Python handles characters / numbers, but the ASCII code of '9' is 54. So if you can write ...>54 you can save a byte.

@CompuChip Python doesn't treat chars or strings as numbers. In fact, Python 2 considers them to be greater than all numbers.

Jelly, 6 bytes
b16>9P

Try it online!
How it works
b16>9P  Input: z

b16     Convert the input to base 16.
   >9   Compare each resulting digit with 9; return 1 iff greater.
     P  Take the product of the resulting Booleans.

Isn't there a built in for 16 or is that not a thing?

There is now. This was one of the first Jelly answers...

TeaScript, 11 bytes 13 15 16
xT(16)O(Sz)

Pretty simple. This uses TeaScript 2.0. You can get this version from the Github
Explanation
        // Implicit: x = input, Sz = alphabet
xT(16)  // input -> hex
O(Sz)   // Only letters?

Try it online (slightly modified version that works on web)

Is the down-vote because this is long? Is there something else wrong with this answer that I'm not aware of? Or does someone just not personally like this answer?

I wouldn't say 16 or 13 bytes is long!

You have to admit that down-goating your posts is pretty tempting.

Python 3, 30 29 bytes
1 byte stripped thanks to sysreq and Python 3.
lambda n:hex(n)[2:].isalpha()

Simple lambda and slicing.

27 bytes using a format string literal

LabVIEW, 52-40 = 12 LabVIEW Primitives
Praise the built-ins!

C, 46 43 37 bytes
Now with more recursion! (Thanks Dennis):
F(x){return(x%16>9)*(x<16?:F(x/16));}

Bonus: even shorter (33 bytes), but fails for x = 0:
F(x){return!x?:(x%16>9)*F(x/16);}

b;F(x){for(b=x;x;x/=16)b*=x%16>9;return b;}

F() takes an int and returns either 0 (false) or non-zero (true).
I didn't even try to achieve the bonus, "MixOnly lettersnumbers" takes 23 bytes alone, tracking the new condition would have required 9 additional bytes, printf() is 8 bytes, which adds up to 40, nullifying the effort.
Test main:
#include <stdio.h>

int main() {
  int testdata[] = {10, 100, 161, 11259375, 0};
  for (int i = 0; i < 5; ++i) {
    int d = testdata[i];
    printf("%d (0x%x) -> %s\n", d, d, F(d)?"yep":"nope");
  }
}

What's ?:? I had to replace it with || to get it to compile. Also, can you save a byte by replacing the * with an & thus avoiding the ()s on the left (although you then have to add a space)?

@Neil a?:b is a GNU extension that evaluates to a if a is a truthy value, otherwise to b. Comes handy to handle null pointers like send(message ?: "(no message)");. I know it's not portable, but code portability is never a concern in code golf :)

@StefanoSanfilippo you can get this down to 33 bytes by doing this: F(x){x=(x%16>9)*(x<16?:F(x/16));} this abuses a (GCC) bug where if there is no return variable in a function and the main argument was set, it will auto-return the main-argument in some cases (based on what logic was done), and this happens to be one of those cases! Try it online: http://bit.ly/2pR52UH

MATL, 10
i16YA1Y2mA

Examples
>> matl i16YA1Y2mA
> 240
0
>> matl i16YA1Y2mA
> 255
1

Explanation
i       % input
16YA    % convert to string representation in base 16
1Y2     % predefined literal: 'A':'Z'
m       % true for set member
A       % all

Bonus challenge: 53−40 = 13
i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]

Examples
>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 >
> 255
Only letters

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 >
> 100
Only numbers

>> matl
 > i16YA1Y2mXKA?'Only letters'}Ka?'Mix'}'Only numbers']]
 >
> 240
Mix

Explanation
i                       % input
16YA                    % convert integer to string representation in base 16
1Y2                     % predefined literal: 'A':'Z'
m                       % true for set member
XK                      % copy to clipboard K
A                       % all
?                       % if (top of the stack)
  'Only letters'        % string literal
}                       % else
  K                     % paste from clipboard K
  a                     % any
  ?                     % if (top of the stack)
    'Mix'               % string literal
  }                     % else
    'Only numbers'      % string literal
  ]                     % end
]                       % end

hmmm what is that ? seems like matlab got some nuc power now !

@Agawa001 Hahaha. Sort of

Mathematica, 32 bytes
Tr@DigitCount[#,16,0~Range~9]<1&

Explanation:
                               &   A function returning whether
Tr@                                 the sum of elements of
   DigitCount[ ,  ,         ]        the numbers of
                   0~Range~9          zeros, ones, ..., nines in
                16                    the hexadecimal expansion of
              #                       the first argument
                             <1     is less than one.

Julia, 18 bytes
n->isalpha(hex(n))

This is an anonymous function that accepts an integer and returns a boolean. To call it, give it a name, e.g. f=n->....
The input is converted to a hexadecimal string using hex, then we check whether its entirely comprised of alphabetic characters using isalpha.

Perl 6, 18 bytes
{.base(16)!~~/\d/} # 18 bytes

usage:
# give it a name
my &code = {.base(16)!~~/\d/}

for 10, 100, 161, 11259375, 0 {
  printf "%8s %6s %s\n", $_, .base(16), .&code
}

      10      A True
     100     64 False
     161     A1 False
11259375 ABCDEF True
       0      0 False

Javascript, ES6, no regexp, 28 bytes
F=n=>n%16>9&&(n<16||F(n>>4))

There's also this 27-byte version but it returns the inverse value.
F=n=>n%16<10||n>15&&F(n>>4)

Nice! You could also rearrange it like this for 23 bytes: F=n=>!n||n%16>9&F(n>>4)

@user81655 - Unfortunately, that version returns true for 0, so it's incorrect.

Oh right, I guess the shortest would be F=n=>n%16>9&&n<16|F(n>>4) then.

@user81655 I'm pretty sure you need to short-circuit the ||, but I think you could get away with using & instead of && in that case.

@Neil Why's that? Did you test it?

@user81655 OK so thinking about it again it doesn't matter which of the two operators short-circuits as long as one of them does. Sorry for the confusion. (I should really avoid commenting after midnight...)

JavaScript ES6, 29
No bonus
n=>!/\d/.test(n.toString(16))

With the new value of -40 the bonus is nearer now ... but not enough. Bonus score 70 71 - 40 => 30 31
n=>/\d/.test(n=n.toString(16))?1/n?'Only numbers':'Mix':'Only letters'

Test snippet (type a number inside the input box)

#I { width:50%}
<input id=I oninput="test()"/>

Hex

Result

-n-1=~n, right?

@CatsAreFluffy if n is not numeric like 'A' (that's the whole point in this challenge), ~n == -1 while -n-1 == NaN

Java, 46 44 38 bytes
i->i.toHexString(i).matches("[a-f]+");

Pretty simple one-liner that converts the integer to a hexadecimal string and uses regex to determine if all characters are letters.
-2 bytes thanks to @Eng.Fouad.

"[a-f]+" would save 2 bytes.

Fails for 516..

@CatsAreFluffy No it doesn't.

Well now it determines if the string contains a hex letter, so remove the +–it's a waste of byte.

@CatsAreFluffy No. matches returns true if the entire string can be matched by the given regex. [a-f] without the plus sign is incorrect since it doesn't match the entire string given that it contains more than one character; it would if and only if one valid character is present.

Oh right. Ok then.

Octave, 22 bytes
@(n)all(dec2hex(n)>64)

Ruby, 19 bytes
->n{!('%x'%n)[/\d/]}

Ungolfed:
-> n {
  !('%x'%n)[/\d/]
}

Usage:
f=->n{!('%x'%n)[/\d/]} # Assigning it to a variable
f[0]
=> false
f[10]
=> true
f[100]
=> false
f[161]
=> false
f[11259375]
=> true

With bonus, 70 - 40 = 30 bytes
->n{'%x'%n=~/^(\d+)|(\D+)$/;$1?'Only numbers':$2?'Only letters':'Mix'}

Usage:
f=->n{'%x'%n=~/^(\d+)|(\D+)$/;$1?'Only numbers':$2?'Only letters':'Mix'}
f[10]
=> Only letters
f[100]
=> Only numbers
f[161]
=> Mix

Late, but '%x'%n!~/\d/ is a shorter check for solution one, and solution two has a raw byte count of 70, not 75.

GS2, 6 bytes
V↔i/◙s

The source code uses the CP437 encoding. Try it online!
How it works
V       Evaluate the input.
 ↔      Push 16.
  i     Perform base conversion.
   /    Sort.
    ◙   Push [10].
     s  Perform greater-or-equal comparison.

Perl, 69 - 40 = 29 bytes
$_=sprintf"%X",<>;print s/\d//?$_?"Mix":"Only numbers":"Only letters"

CJam (9 8 bytes)
{GbA,&!}

Online demo

Equally short: {Gb$N<!}

Ceylon, 55 bytes
Boolean l(Integer n)=>!any(formatInteger(n,16)*.digit);

Straightforward ... we format n as a hexadecimal number (which produces a string), call on each character of that string the .digit number (which returns true if it is a digit), then check whether any of them are true, then negate this.
The version with bonus has a lot higher score of 119 - 25 = 94:
String c(Integer n)=>let(s=formatInteger(n),d=s*.digit)(every(d)then"Only numbers"else(any(d)then"Mix"else"Only letters"));

I'm not sure how anyone could make a bonus version short enough to be better than the no-bonus version, even those strings alone have length 28 together. Maybe a language which makes it really hard to produce a truthy/falsey value.
Here is a formatted version:
String c(Integer n) =>
        let (d = formatInteger(n,16)*.digit)
    (every(d) then "Only numbers"
                else (any(d) then "Mix"
                    else "Only letters"));

Seriously, 12 bytes
4ª,¡OkúOkd-Y

Hex Dump:
34a62cad4f6b
a34f6b642d59

Try It Online
It's the same as the other stack language answers. It would be only 7 bytes if Seriously supported string subtraction yet.
EDIT: Seriously now supports string subtraction and the following 7 byte solution now works:
ú4╙,¡-Y

Hex Dump:
a334d32cad2d59

Try It Online

11: 4╙,¡#S;ú∩S= (or 4ª or 8τ, lots of ways to spell :16: in two bytes :P)

I didn't know S I think.

SmileBASIC 3.2.1, 78 bytes
INPUT V FOR I=0 TO 9
IF INSTR(HEX$(V),STR$(I))>-1 THEN ?"FALSE"END
NEXT?"TRUE"

I don't see any non-ASCII characters here (unless there are some); this counter is the definitive decider and it says 81.

It doesn't matter that the implementation uses UTF-16 internally; to the rest of the world they may as well be UTF-8 chars in the range 0-127, thus your byte count is 81.

Thanks for the feedback, wasn't sure if "bytes" meant I should count 2 per char. 81 it is.

Actually, the current +10/-0 consensus (which, by the way, I now disagree with) is that we must always use the encoding that an interpreter uses. If you disagree, please post a dissenting opinion on that question.

@ThomasKwa pfft, okay, oops, now I know better. I didn't realise there was a consensus about that, and I spend a fair bit of time on meta.

Can you not save 3 bytes by writing the entire conditional inside the IF statement?

@Neil Ah, you are indeed right. I'll fix that (as well as fixing my byte count.)

@lirtosiast, I created a meta post asking how to score SmileBASIC here.

Rust, 70 bytes
fn f(n:i32)->bool{format!("{:x}",n).chars().all(|c|c.is_alphabetic())}

Because, ya know, Java Rust.
It's actually quite elegant, though:
format!("{:x}", n)         // format n as hex (:x)
  .chars()                 // get an Iter over the characters
  .all(                    // do all Iter elements satisfy the closure?
    |c| c.is_alphabetic()  // self-explanatory
  )

But it's a shame the function definition boilerplate is so long.... :P

I have an idea. More closures!

CJam, 44 bytes - 40 bonus = 4 bytes
2,riGbAf/&:-"Only numbersOnly lettersMix"C/=

Try it here~

05AB1E, 2 bytes
Code:
ha

Ha! That is two bytes! Sadly non-competing because this language postdates the challenge :(
Explanation:
h   # Convert input to hexadecimal
 a  # is_alpha, checks if the value only contains letters

Try it online! or Verify all test cases!

hdÔ©1åi•4?ŸâÏ„Î›•}®0åi•4?ŸàpÕTà•}®g2Qi•²•}36B` for the bonus resulting in... 6 more! Wooooo bonuses!

Ruby, 16 bytes
->n{/\d/!~'%x'%n}

Ruby, 70 bytes - 40 bonus = 30
f=->n{s="Only #{n%16<10?:Numbers:'Letters'}";n<16||s==f[n/16]?s:'Mix'}

Amazingly, the other Ruby poster miscounted their solution w/ bonus and they also have 30 as their final score. But hey, it's a different and unique solution!

Python 3, 28 bytes
lambda x:min(hex(x)[1:])>'@'

Common Lisp, 40 bytes
(every'alpha-char-p(format()"~x"(read)))

Try it online!

Japt, 12 bytes
!UsG r"[a-f]

Try it online!
How it works
!UsG r"[a-f] // Implicit: U = input integer, G = 16
 UsG         // Convert U to a base-16 string.
     r"[a-f] // Replace all lowercase letters with an empty string.
!            // Take the logical NOT of the result.
             // This returns true for an empty string; false for anything else.

I think !!UsG r"\\d might work and save a byte

@Downgoat Good observation, but that returns true for any number that contains a letter.

Haskell, 39 bytes
p n|mod n 16<10=0|n<16=1|1<2=p$div n 16

Returns 0 or 1. Usage example:
*Main> map p [10,100,161,11259375,0]
[1,0,0,1,0]

Haskell has neither built-in base conversion nor check for letters. Both functions are in modules where the imports alone would cost 36 bytes, so that's not an option. Instead I check the input number n for:

if mod n 16 is less than 10 -> False
if n is less than 16 -> True
otherwise re-check with n/16.

C, 132 bytes
int main(){int a=0,p=1;char b[256];scanf("%d",&a);sprintf(b,"%x",a);for(char*c=b;*c!='\0';c++)if(isdigit(*c)){printf("False");p=0;}if(p)printf("True");return 0;}

Detailed
int main()
{
    int a=0, p=1;
    char b [256];

    scanf("%d",&a); // read input as an integer
    sprintf(b,"%x",a); // read in Hex into string

    for(char * c=b; *c!='\0'; c++)
    {
        if(isdigit(*c)) // if it's a digit
        {
            printf("%x No",a);
            p=0;
        }
    }

    if(p) // if no digit was found
    {
        printf("%x Yes",a);
    }

    return 0;
}

Bonus, 232 - 40 = 192 bytes
int main(){int a=0, p=0,q=0;char b [256];scanf("%d",&a);sprintf(b,"%x",a);for(char * c=b; *c!='\0'; c++) if(isdigit(*c)) p=1; else q=1;if(p&&q) printf("Mixed");else if(p) printf("Only numbers");else printf("Only letters");return 0;}

Detailed
int main()
{
    int a=0, p=0,q=0;
    char b [256];

    scanf("%d",&a);
    sprintf(b,"%x",a);

    for(char * c=b; *c!='\0'; c++) if(isdigit(*c)) p=1; else q=1;

    if(p&&q) printf("Mixed");
    else if(p) printf("Only numbers");
    else printf("Only letters");

    return 0;
}

main() does not return void in standard C.

@Peter fixed it now, it's weird given I've read it in a book during my study. C89 turned out that you can write main() and the return type will be assumed as int

PHP, 56 44 bytes
This isn't going to win, but might as well. Takes one command-line argument.
Thank you @Blackhole for reducing this by 12 bytes.
<?=ctype_lower(base_convert($argv[1],10,16))

// Previous attempt, 56 bytes
<?=preg_match('#^[a-f]+$#',base_convert($argv[1],10,16))

I'm pleased to introduce you the ctype_alpha() function ;).

@Blackhole Ahh thank you. Gotta love PHP, functions for everything :)

dechex() saves 11 bytes.

Gema, 41 characters
*=@c{@radix{10;16;*}}
c:<D>=f@end;?=;\Z=t

There is no boolean in Gema, so it simply outputs “t” or “f”.
Sample run:
bash-4.3$ echo -n '11259375' | gema '*=@c{@radix{10;16;*}};c:<D>=f@end;?=;\Z=t'
t

Perl, 24 bytes
$_=sprintf"%x",$_;$_=/\D/&/\d/?Mix:Only.$".(/\d/?numb:lett).ers

Code is 63 bytes, add 1 for the -p flag, and then subtract 40 for the bonus.

Binary-Encoded Golfical, 50+1 (-x flag)=51 bytes
Noncompeting; the modulo instruction used here, although it was added to the specs, according the repo's revision history, on the same day this question was posted, was for some reason never implemented until earlier today.
Hexdump:
00 C0 03 15 14 14 1B 1A 14 08 01 14 17 00 10 14
00 01 0A 01 21 1E 2C 3D 14 53 2D 14 08 01 0A 01
1C 00 0A 00 10 17 0A 01 08 01 00 00 26 14 1E 1C
1D 14

This encoding can be converted back to the original graphical form using the included Encoder utility, or run directly by adding the -x flag.
Original image:

Magnified 50x:

Rough translation:
prompt *p
label A
push *p
*p%=16
if *p<10
 print 0
 exit
endif
*p=pop
*p/=16
if *p==0
 print 1
 exit
endif
goto A

PHP, 32 bytes
since rink.attendant.6 won´t react; I post my own.
echo+ctype_alpha(dechex($argn));

takes input from STDIN; prints 1 or 0; run with -R.
bonus attempt, 93 87-40=47
5 bytes saved by Jörg, 1 by me
echo(ctype_alpha($s=dechex($argn))+$d=ctype_digit($s))?"Only ".[lett,numb][$d].ers:Mix;

takes input from STDIN; run with -nR.
btw. ctype_xdigit would be an option for Mix and help serialize (though pi is the shortest alternative); but I guess it can´t get any shorter than Jörgs idea with my golfing.
The more you serialize, the longer it gets.
a partly serialized version for 101 100-40=60:
2 bytes saved and 1 byte fixed by Jörg
echo strtr([ctype_alpha($s=dechex($argn))=>_letters,ctype_digit($s)=>_numbers,Mix][1],[_=>"Only "]);

and fully serialized for 114 112-40=72:
-2 bytes inspired by Jörg
foreach([pi=>Mix,ctype_alpha=>lett,is_numeric=>numb]as$f=>$t)$f(dechex($argn))&&$s=$t<a?$t:"Only $t".ers;echo$s;

wonderful I found a shorter approach echo ctype_alpha($s=dechex($argn))+($d=ctype_digit($s))?"Only ".[lett,numb][$d].ers:Mix; or echo ctype_alpha($s=dechex($argn))+($d=ctype_digit($s))?$d?"Only numbers":"Only letters":Mix; with the same byte count for the bonus version

@JörgHülsermann Thanks. And another byte shorter if you place the parentheses differently.

I found your old version  more interesting! And you can save two Bytes if you change the order echo[ctype_alpha($s=dechex($argn))=>"Only letters",ctype_digit($s)=>"Only numbers",Mix][1];  Could you please add your old version as tip for PHP. And please add a closing ] in the partly serialized version

Thunno 2, 30 bytes - 40 = -10
ḤDA?‘Ṇß ɱṀ‘ʂ:dAS?ʋMix:‘Ṇß ḶẸ‘ʂ

Try it online!
Thunno 2, 2 bytes
ḤA

Try it online!
Explanation
Ḥ               # Convert to hexadecimal
 D              # Duplicate it
  A             # Is it all alphabetic?
   ?            # If it is:
    ‘Ṇß ɱṀ‘ʂ    #  Push compressed string "Only letters"
            :   # Otherwise:
             dA #  Check if each character is alphabetic
S?              #  If at least one is true:
  ʋMix          #   Push the string "Mix"
      :         #  Otherwise:
       ‘Ṇß ḶẸ‘ʂ #   Push compressed string "Only numbers"

Ḥ   # Convert to hexadecimal
 A  # Is it all alphabetic?

Swift 5.9, 61 58 51 bytes
let l={String($0+0,radix:16).allSatisfy(\.isCased)}

I chose to use isCased rather than isLetter in order to save a byte.

CoffeeScript, 42 36 bytes
f=(x)->/^[a-f]+$/.test x.toString 16

// Previous attempt (42)
f=(x)->!x.toString(16).replace /[a-f]/g,''

JavaScript (ES6), 41 36 bytes
f=x=>/^[a-f]+$/.test(x.toString(16))

// Previous attempt (41)
f=x=>!x.toString(16).replace(/[a-f]/g,``)

You can remove the f= from the javascript one.

R, 34 bytes
!grepl("\\d",sprintf("%x",scan()))

scan() takes an integer from stdin, sprintf("%x",...) returns the hexadecimal representation of that integer (R's sprintf is equivalent to C's sprintf), then the regex checks if the string contains digits.
Usage:
> !grepl("\\d",sprintf("%x",scan()))
1: 100
2:
Read 1 item
[1] FALSE
> !grepl("\\d",sprintf("%x",scan()))
1: 10
2:
Read 1 item
[1] TRUE
> !grepl("\\d",sprintf("%x",scan()))
1: 161
2:
Read 1 item
[1] FALSE
> !grepl("\\d",sprintf("%x",scan()))
1: 11259375
2:
Read 1 item
[1] TRUE
> !grepl("\\d",sprintf("%x",scan()))
1: 0
2:
Read 1 item
[1] FALSE

, 9 chars / 16 bytes
!ïⓧċ/[α]⌿

Try it here (Firefox only).
Regex aliases ftw!
Explanation
        // Implicit: ï = input
!       // logical-negate the result of the following code:
 ïⓧ    // convert ï to hex...
 ċ/[α]⌿ // and see if it has any letters
        // implicit output

Pyke, 6 bytes
b16G-!

Try it here!
Or 10 bytes with the bonus
b16\9L>]0}DlRs*"Only numbers,Only letters,Mix"\,c@

Explanation:
b16                                                -      base_16(input())
   \9L<                                            -     map("9">char for char in ^)
       ]0                                          -    list(^)
         }                                         -   set(^)
          DlRs*                                    -  len(^)*sum(^)
                                                 @ - V[^]
               "Only numbers,Only letters,Mix"\,c  -  str.split(",")

Try it here!

SmileBASIC, 52 50 bytes
INPUT V
H$=HEX$(V)WHILE""<H$P=@A<POP(H$)||P
WEND?P

Determines if each digit is a number or letter by comparing it with @A (the A doesn't matter since it would only look at it if the first characters were the same). @ is between the number and the letters in ASCII.

MATL, 7 bytes
1YAtk=~

Explanation:
1       % number literal
YA      % convert integer to string representation in given base (16)
t       % duplicate elements
k       % convert (the second) string to lowercase
=       % is equal?
~       % logical 'not' (element-wise)
        % (implicit) convert to string and display

For only letters to be in the base-16 representation, when the string is made lowercase every character must have changed, so the arrays should never be equal to each other, and only arrays of ones are truthy in MATL.
Bonus challenge, 47-40 = 7 bytes:
1YAtk=XK?'Only numbers'}Ka?'Mix'}'Only letters'

Essentially the same as the other MATL answer given, the same ending was used just without trailing ]] and with reordering the outputs.

Befunge (quirkster flavor), 34 bytes
&:44*%9`!#@ #. #0_44*/:!#@ #. #1_#

Befunge control flow loops around to the beginning when it hits the end, so a recursive solution is pretty natural. If the input is less than 9 modulo 16, print 0 (the only falsey value in Befunge) and exit. If not, divide the number by 16, rounding down. If it's now 0, print 1 and exit, otherwise recurse. In effect, this checks each hex digit from right to left.

Clojure, 35 bytes
#(every?(set"abcdef")(format"%x"%))

tcl, 35
puts [string is alp [format %x $n]]

demo

Pushy, 16 bytes
$&16%v16/;OKT)P#

Try it online!
Essentially calculates all digits as numbers 0-16, and then checks they are all over 10.
                    \ Implicit: Input on first stack
$        ;          \ While input != 0:
 &16%v              \   Push input % 16 to second stack
      16/           \   Floordiv input by 16
          O         \ Go to second stack
           KT)      \ Map all numbers to boolean: bigger than 10?
              P     \ Get the product (only 1 if all values are 1)
               #    \ Print result.

Excel, 121 bytes
=LEN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(DEC2HEX(A2),"A",),"B",),"C",),"D",),"E",),"F",))=0

Nothing graceful about this one.

Scala 3, 32 bytes
_.toHexString.forall(_.isLetter)

Attempt This Online!


text:
Most logical rectangle formula from numbers
Introduction
The task is simple. When given a number, output the most logical rectangle. To explain what a logical rectangle is, I provided some examples:
Input: 24.
All possible rectangles have the form A x B, (A and B are both positive integers). So, all possible rectangles for 24 are:

1 x 24
2 x 12
4 x 6

From this list, the most logical rectangle has the lowest A + B:

1 + 24 = 25
2 + 12 = 14
4 + 6 = 10

You can see that 4 x 6 is the most logical rectangle, so we will output 4 x 6 (or 6 x 4).
The rules

Given an integer from 1 to 99999, output the most logical rectangle.
You may write a function or a program.
The spaces in the output are not required.
This is code-golf, so the submission with the least amount of bytes wins!

Test cases
Input >   Output

1     >   1 x 1
4     >   2 x 2
8     >   4 x 2 (or 2 x 4)
15    >   5 x 3 (or 3 x 5)
47    >   1 x 47 (or 47 x 1)
5040  >   72 x 70 (or 70 x 72)
40320 >   210 x 192 (or 192 x 210)

CJam, 26 bytes
ri_mQ),W%{1$\%!}=:X/" x "X

or
ri_mQ{)1$\%!},W=):X/" x "X

Test it here.
Finds the largest divisor less than or equal to the square root of the input as one of the two side lengths.

Pyth, 18 bytes
jd[Kf!%QTs@Q2\x/QK

Try it online: Demonstration or Test Suite
Same idea as Martin's. Finds the first number >= floor(sqrt(n)), that divides n.
Explanation:
jd[Kf!%QTs@Q2\x/QK   implicit: Q = input number
          @Q2        sqrt(Q)
         s           floor, converts ^ to an integer
    f                find the first number T >= floor(sqrt(Q)), that satisfies:
     !%QT               Q mod T == 0
   K                 store this number in K
  [K         \x/QK   create the list [K, "x", Q/K]
jd                   join by spaces

Java 8, 86 bytes
n->{for(int i=(int)Math.sqrt(n);;i--)if(n%i==0){System.out.print(i+"x"+n/i);return;}};

Lambda function, test with:
public class Rectangle {
    interface Test {
        void run(int v);
    }
    public static void main (String[] args){
        Test test = n->{for(int i=(int)Math.sqrt(n);;i--)if(n%i==0){System.out.print(i+"x"+n/i);return;}};

        int[] testCases = {1, 4, 8, 15, 47, 5040, 40320};
        for (int i : testCases) {
            test.run(i);
            System.out.println();
        }
    }
}

Finds the largest divisor less than or equal to the square root of the input. Same concept as the CJam and Pyth answers.

source: Stack Exchange

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

sort: votes


text:
Check if a UUID is valid without using regexes
Given a string input, write a program that prints a truthy value to STDOUT or equivalent if the input is a valid UUID, without using regexes.
A valid UUID is

32 hexadecimal digits, displayed in five groups separated by hyphens, in the form 8-4-4-4-12 for a total of 36 characters (32 alphanumeric characters and four hyphens).
Source

Test Cases
0FCE98AC-1326-4C79-8EBC-94908DA8B034
    => true
00000000-0000-0000-0000-000000000000
    => true
0fce98ac-1326-4c79-8ebc-94908da8b034
    => true
0FCE98ac-1326-4c79-8EBC-94908da8B034
    => true

{0FCE98AC-1326-4C79-8EBC-94908DA8B034}
    => false (the input is wrapped in brackets)
0GCE98AC-1326-4C79-8EBC-94908DA8B034
    => false (there is a G in the input)
0FCE98AC 1326-4C79-8EBC-94908DA8B034
    => false (there is a space in the input)
0FCE98AC-13264C79-8EBC-94908DA8B034
    => false (the input is missing a hyphen)
0FCE98AC-13264-C79-8EBC-94908DA8B034
    => false (the input has a hyphen in the wrong place)
0FCE98ACD-1326-4C79-8EBC-94908DA8B034
    => false (one of the groups is too long)
0FCE98AC-1326-4C79-8EBC-94908DA8B034-
    => false (has a trailing hyphen)
0FCE98AC-1326-4C79-8EBC-94908DA8B034-123
    => false (too many groups)
0FCE98AC13264C798EBC94908DA8B034
    => false (there is no grouping)

Rules

Regular Expressions are not allowed
Literal pattern matching which is like a regex is not allowed. For example, using [0-9a-fA-F] or other hexadecimal identifiers (we'll call this n) and then matching nnnnnnnn-nnnn-nnnn-nnnn-nnnnnnnnnnnn or n[8]-n[4]-n[4]-n[4]-n[12] is not allowed
The input may either be taken from STDIN or as an argument to a function
The input is case insensitive
It is safe to assume that the input will not contain linefeeds or newlines.
The input may contain any printable ASCII characters (spaces included)
A truthy value  must be printed to STDOUT or equivalent if the input is a valid uuid
A falsey value  must be printed to STDOUT or equivalent if the input is not a valid uuid
If using a function, instead of using STDOUT, the output can be the return value of the function
The truthy/falsey value cannot be printed to STDERR.
Standard loopholes apply
This is code-golf, so the shortest program in bytes wins. Good luck!

Leaderboard
This is a Stack Snippet that generates both a leaderboard and an overview of winners by language.
To ensure your answer shows up, please start your answer with a headline using the following Markdown template
## Language Name, N bytes

Where N is the size, in bytes, of your submission
If you want to include multiple numbers in your header (for example, striking through old scores, or including flags in the byte count), just make sure that the actual score is the last number in your header
## Language Name, <s>K</s> X + 2 = N bytes

var QUESTION_ID=66496;var OVERRIDE_USER=20634;function answersUrl(e){return"//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"//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

Poor Retina. D:

Related

Just for reference, I can come up with a 28-byte Retina solution. (So not a crazy advantage over the golfing languages although it would currently be leading.)

Are Lua's patterns allowed? They are certainly not regular expressions.

You have to make language list case insensitive...

What should the output be for 0FCE98AC13264C798EBC94908DA8B034?

Expanding the question - what should the output be for input.length!=36? e.g. {dddddddd-dddd-dddd-dddd-dddddddddddd}, {0xdddddddd, 0xdddd, 0xdddd,{0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd}}

@JacobKrall I'm pretty sure it's "falsy" to all of your questions. I think the challenge is fairly clear that only strings of the form \h{8}-\h{4}-\h{4}-\h{4}-\h{12} (where \h is a hexadecimal digit) are valid.

@MartinBüttner: I agree, but there are currently several answers which use built-in uuid constructors, which accept other formats.

@MartinBüttner If that's indeed the case, the question should be edited to explicitly state that it is expecting canonical-form parsing, and not just valid-UUID parsing. 0FCE98AC13264C798EBC94908DA8B034 is a valid UUID, just not in canonical form.

@Jojodmo Those test cases, particularly the one without hyphens, were added after a majority of answers were posted, mine included. Hence my asking for clarification.

Are scanf()-style format specifiers also disgualified as being like a regex?

@Jojodmo I guess that disqualifies both my answers then :(.  I'm still leaving them up though as I think this was not clear in the question as originally written.

@What about APIs like isxdigit() which operate on a single character at a time?

@DigitalTrauma isxdigit would be fine. Also, I'm pretty sure you posted your answer before I added the part about literal pattern matching, so feel free to leave it up, just make sure you say that it is not competative

Can answers use .NET languages and call System.Guid.TryParse?

@phoog Yes, but it has to only accept the format 8-4-4-4-12

CJam, 31 30 29 bytes
8 4__C]Nf*'-*qA,s'G,_el^+Ner=

Run all test cases here.
Explanation
Instead of pattern matching the input directly, we're first transforming it to a simpler form which can be easily compared against a single pattern string.
8 4__C] e# Push the array of segment lengths, [8 4 4 4 12].
Nf*     e# Turn that into strings of linefeeds of the given length.
'-*     e# Join them by hyphens, giving "NNNNNNNN-NNNN-NNNN-NNNN-NNNNNNNNNNNN".
q       e# Read the input.
A,s     e# Push the string "0123456789".
'G,_el^ e# Push the string "ABCDEFabcdef".
+       e# Concatenate the two strings.
N       e# Push a linefeed.
er      e# Replace all hexadecimal digits with linefeeds.
=       e# Check for equality with the pattern string.

JavaScript ES6, 73 55 56 chars
s=>s.split`-`.map(x=>x.length+`0x${x}0`*0)=="8,4,4,4,12"

The previous 55 chars version has a problem with trailing spaces in group:
s=>s.split`-`.map(x=>x.length+("0x"+x)*0)=="8,4,4,4,12"
// "00000000-0000-0000-000 -000000000000" true

Test:
f=s=>s.split`-`.map(x=>x.length+`0x${x}0`*0)=="8,4,4,4,12"
;`0FCE98AC-1326-4C79-8EBC-94908DA8B034
0fce98ac-1326-4c79-8ebc-94908da8b034
0FCE98ac-1326-4c79-8EBC-94908da8B034
0GCE98AC-1326-4C79-8EBC-94908DA8B034
0FCE98AC-13264C79-8EBC-94908DA8B034
0FCE98AC-13264-C79-8EBC-94908DA8B034
0FCE98ACD-1326-4C79-8EBC-94908DA8B034
0FCE98AC-1326-4C79-8EBC-94908DA8B034-123
00000000-0000-0000-0000-000000000000
D293DBB2-0801-4E60-9141-78EAB0E298FF
0FCE98AC-1326-4C79-8EBC-94908DA8B034-
00000000-0000-0000-000 -000000000000`.split(/\n/g).every(s=>f(s)==/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i.test(s))

Awesome (and withering for me) +1

@edc65, what do you mean by "withering"?

Awesome abuse of implicit casting +1

scornful, contemptuous, scathing, stinging, devastating, humiliating, mortifying - (comparing your answer to mine)

PowerShell, 29 21 84 49 37 Bytes
param($g)@{36=$g-as[guid]}[$g.length]

Many thanks to the folks in the comments assisting with this golfing to keep up with the changing rules -- TessellatingHeckler, iFreilicht, Jacob Krall, and Joey. Please see the edit history for revisions and older versions.
This revision takes input as $g, then creates a new hash table @{} with one element, index 36 is set equal to $g-as[guid]. This uses the built-in -as operator to attempt conversion between two .NET data types -- from [string] to [guid]. If the conversion is successful, a [guid] object is returned, else $null is returned. This portion ensures that the input string is a valid .NET GUID.
The next step is to index into the hash table with [$g.length]. If $g is not exactly 36 characters in length, the hash table will return $null, which will be output as a falsey value. If $g is 36 characters in length, then the result of the .NET call will be output. If $g is not a valid .NET GUID (in any form), then it will output $null as a falsey value. Otherwise it will output a .NET GUID object as a truthy value - the only way that can be output is if it matches the requested format of the challenge.
Examples
Here I am encapsulating the script call in parens and explicitly casting as a Boolean for clarity.
PS C:\Tools\Scripts\golfing> [bool](.\check-if-a-uuid-is-valid.ps1 '0FCE98AC-1326-4C79-8EBC-94908DA8B034')
True

PS C:\Tools\Scripts\golfing> [bool](.\check-if-a-uuid-is-valid.ps1 '0FCE98AC-1326-4C79-8EBC-94908DA8B034D')
False

PS C:\Tools\Scripts\golfing> [bool](.\check-if-a-uuid-is-valid.ps1 '0FCE98AC13264C798EBC94908DA8B034')
False

I'll throw in !!($args[0]-as[guid]) at 21 bytes.

Couldn't you just save 4 bytes by leaving out the !!()? As the values $NULL and [guid] are mutually exclusive, they qualify to represent truthey and falsey values, don't they?
Anyway, great way to convert to boolean, love the solution!

@iFreilicht that is a point; looking at the linked "truthy/falsey interpretation" post - I agree it looks valid.

This solution incorrectly returns True for 0FCE98AC13264C798EBC94908DA8B034, which has no hyphens

@TimmyD: I disagree with your interpretation of the question, even as-of yesterday. The revision you link to contains the verbatim text "A valid UUID is 32 hexadecimal digits, displayed in five groups separated by hyphens, in the form 8-4-4-4-12 for a total of 36 characters (32 alphanumeric characters and four hyphens)." Therefore we can infer that, for the purposes of this question, any other representation is not a valid UUID.

@JacobKrall: That's something that can only be resolved by resorting to try{!![guid]::parseexact("$args",'d')}catch{0}, I think.

@TessellatingHeckler That is a really clever way of "counting" the length of the string, seems like a really good solution.

@TessellatingHeckler Nope, too good to be true. Appending a digit, such as 0FCE98AC-1326-4C79-8EBC-94908DA8B034D (extra D on the end) returns falsey $TRUE, since it just trims the offending digit away and the first 36 characters are valid.

@Joey Thanks for the assist. I combined your suggestion with iFreilicht and golfed a few more bytes.

@TimmyD: I think TesselatingHeckler had a better solution already. It's just that I haven't read that comment when I wrote my own.

@TimmyD annoying edge case, but good catch. Still, 49 bytes cannot stand, how about param($g)@{36=$g-as[guid]}[$g.Length] at 37 bytes? All 5 formats .Net handles will convert - but only the one we care about will have the right length to index the hashtable and appear as script output. Incorrect lengths will get a hashtable $null default return. Incorrect inputs of the right length can't be valid GUIDs so they will convert to $null, lookup in the hashtable and have $null output as well.

Emacs Lisp, 236 Bytes
(lambda(s)(and(eq(string-bytes s)36)(let((l(string-to-list s))(i 0)(h '(8 13 18 23))(v t))(dolist(c l v)(set'v(and v(if(member i h)(and v(eq c 45))(or(and(> c 47)(< c 58))(and(> c 64)(< c 91))(and(> c 96)(< c 123))))))(set'i(+ i 1))))))

Ungolfed:
(lambda (s)
  (and (eq (string-bytes s) 36) ; check length
       (let ((l (string-to-list s))
             (i 0)
             ; location of hyphens
             (h '(8 13 18 23))
             (v t))
         (dolist (c l v)
           (set 'v (and v (if (member i h)      ; check if at hyphen position
                              (and v (eq c 45)) ; check if hyphen
                            (or (and (> c 47) (< c 58))      ; check if number
                                (and (> c 64) (< c 91))      ; check if upper case letter
                                (and (> c 96) (< c 123)))))) ; check if lower case letter
           (set 'i (+ i 1)))))) ; increment

Due to changes to the rules, this answer is no longer competitive :(
C, 98
main(a,n){printf("%d",scanf("%8x-%4hx-%4hx-%4hx-%4hx%8x%n%c",&a,&a,&a,&a,&a,&a,&n,&a)==6&&n==36);}

Mostly fairly self explanatory.  The %n format specifier gives the number of bytes read so far, which should be 36.  scanf() returns the number of matched items, which should be 6.  The final %c should not match anything.  If it does, then there is trailing text, and scanf() will return 7.
Compile with -w to suppress the pesky warnings (there are several).

JavaScript ES6, 70 83
NOTE thx to @Qwertiy for finding a bug (and suggesting some improvements and fixes)
Thx @CᴏɴᴏʀO'Bʀɪᴇɴ 2 bytes saved
Other 9 bytes saved simplifiying the length check (the complex way was shorter in the first draft, but not now)
u=>u.split`-`.every((h,l,u)=>u[4]&&-`0x${h}1`&&h.length-'40008'[l]==4)

Explained
u=>u.split`-` // make an array splitting at '-'
.every( // for every element the following must be true
 (h,l,u)=> // h is the element, l is the index, u is the whole array
 u[4] // element 4 must be present (at least 5 element in array)
 && -`0x${h}1` // element must be a valid hex string with no extraneous blanks (else NaN that is falsy)
 // get requested length from index (8,4,4,4,12 sub 4 to put in 1 char)
 // a 6th elements will be rejected as undefined != 4
 && h.length-'40008'[l]==4// then check element length
)

Test snippet

f=u=>u.split`-`.every((h,l,u)=>u[4]&&-`0x${h}1`&&h.length-'40008'[l]==4)

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

;[
  ['0FCE98AC-1326-4C79-8EBC-94908DA8B034',true],
  ['0fce98ac-1326-4c79-8ebc-94908da8b034',true],
  ['0FCE98ac-1326-4c79-8EBC-94908da8B034',true],
  ['00000000-0000-0000-0000-000000000000', true],
  ['ffffffff-ffff-ffff-ffff-ffffffffffff', true],
  ['0GCE98AC-1326-4C79-8EBC-94908DA8B034',false],
  ['0FCE98AC-13264C79-8EBC-94908DA8B034',false],
  ['0FCE98AC-13264-C79-8EBC-94908DA8B034',false],
  ['0FCE98ACD-1326-4C79-8EBC-94908DA8B034',false],
  ['0FCE98AC-1326-4C79-8EBC',false],
  ['0FCE98AC-1326-4C79-8EBC-94908DA8B034-',false],
  ['00000000-0000-0000-000 -000000000000', false],
  ['0FCE98AC-1326-4C79-8EBC-94908DA8B034-123',false],
].forEach(x=>{
  var t=x[0], r=f(t), k=x[1]
  console.log('Test '+t+' result '+r+(r==k?' ok':' fail'))
})

-1-('0x'+h) => 1/('0x'+h)

Same problem as in my previous version: true for 00000000-0000-0000-000 -000000000000

No. But y've added a wrong test. Leading space is not a problem, but trailing one is, as a string is trimmed when converting to number. See my comment above with a test.

'00000000-0000-0000-000 -000000000000' now I see it @Qwertiy I missed the 3 zeros instead of 4

'40008x' => '40008' as undefined is not equal to 4.

@Qwertiy no matter how hard you try, I can't reach your score

By the way, I don't think it was a bug as explicit rule about spaces have appeared later.

http://codegolf.stackexchange.com/a/63494/32091 sometimes the length becomes significantly reduced :)

@Stefnotch i don't agree. Outside the every call u is a string, not an array

Due to changes to the rules, this answer is no longer competitive :(
Pure Bash (no external utilities), 78
printf -vv %8s-%4s-%4s-%4s-%12s
p=${v// /[[:xdigit:]]}
[ "$1" -a ! "${1/$p}" ]

Takes input from the command line.

The printf builds the following string -    -    -    -.
The p= line transforms this to the following pattern: [[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]-[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]-[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]-[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]]-[[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]][[:xdigit:]].  Note this looks an awful lot like a regular expression.  However, it is not in this context.  It is a pattern for shell pattern matching.  This is similar in concept to a regular expression, but is a different construct (and syntax).
The last line checks if

the input is non-empty
if pulling the pattern out of the input string produces an empty string

Idiomatic to shell, a return code of 0 indicates success/TRUE and 1 indicates failure/FALSE.  The return code may be inspected with echo $? after running the script.

The shell pattern matching may not follow the syntax of regex, but the character class definitely uses the definition and syntax from POSIX regex. Anyway, it's up to OP to decide whether it's acceptable.

@n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Regular expressions may include Posix character classes, but I don't think that implies that anything that uses a Posix character class is a regex.  As another example tr also uses Posix character classes, but is not a regex parser.

You can shave off a few characters by avoiding useless double quotes, e.g. in the printf format.

I've updated the challenge to clarify - the reason regexes were disallowed was to make it so hex patterns could not be used to match uuids

Jolf, 32 bytes
Try it here!
 eGi'-DN&bH*28=lH.[8,4,4,4,12]S}
 e                               Property "e"very of next object
  Gi'-                           Split i at hyphen
      DN                       } every comparison function
        &                        logical conjugation of next two arguments
         bH*28                   base 16 of H (first arg); is NaN (falsey) if invalid
              =                  equality of next two items
               lH                the length of H (first arg)
                 .            S  the Sth (index) member of the object inbetween
                  [8,4,4,4,12]   array of lengths

Because of an error in my code, this is longer than it should be. :( [8,4,4,4,12] should be the same as {8444*26}, but } is also the closing of a function :P

So it is longer than it has to be because you have ambiguous commands in the language you created? :P

@RikerW Minor semantic mistake. It is fixed now.

MATL, 55 bytes
jttn36=?[9,5,5,5]XsXK)45=?36:Km~)4Y2'A':'F'hm?}F]]]N~1$

I refrained from using the Yb function (strsplit) because it's somewhat similar to regexp(..., 'split'). This only uses indexing and character comparisons.
Example
>> matl
 > jttn36=?[9,5,5,5]XsXK)45=?36:Km~)4Y2'A':'F'hm?}F]]]N~1$
 >
> This is a test
0

>> matl
 > jttn36=?[9,5,5,5]XsXK)45=?36:Km~)4Y2'A':'F'hm?}F]]]N~1$
 >
> D293DBB2-0801-4E60-9141-78EAB0E298FF
1

Explanation
jt                     % input string, duplicate
tn36=?                 % if length is 36
  [9,5,5,5]XsXK        % build and copy indices of required '-' positions
  )45=?                % if those entries are indeed '-'
    36:Km~)            % logical index of remaining positions
    4Y2'A':'F'h        % allowed chars in those positions
    m?                 % if all those entries are legal: do nothing
    }                  % else
      F                % false value
    ]                  % end
  ]                    % end
]                      % end
N~                     % true if stack is empty
1$                     % display last result only

CJam, 52 42 bytes
qeu__{A7*)<},\'-/83 3b{)4*}%.{\,=}[1]5*=*=

Try it online. Outputs the original string if true, outputs empty string if false (this is allowed).
Explanation:
qeu__                                      e# Take input, make 2 copies
     {A7*)<},\                             e# Remove invalid characters from first copy
              '-/                          e# Split top of stack on '-
                 83 3b{)4*}%               e# Array of group lengths: [8 4 4 4 12]
                            .{\,=}[1]5*=   e# Compare two arrays, return true if group lengths are correct
                                        *= e# Multiply this value by original string (0 = empty string, 1 = same string)

A7*)< will not remove many invalid characters, like spaces, +, ? ...

@MartinBüttner oh shoot... I did not realize that, Ill fix it in a few minutes.

Julia, 86 bytes
s->(t=split(s,"-");map(length,t)==[8,4,4,4,12]&&all(i->!isnull(tryparse(Int,i,16)),t))

This is an anonymous function that accepts a string and returns a boolean. To call it, give it a name, e.g. f=s->....
Ungolfed:
function f(s::AbstractString)
    # Split the input into an array on dashes
    t = split(s, "-")

    # Ensure the lengths are appropriate
    ok1 = map(length, t) == [8, 4, 4, 4, 12]

    # Ensure each element is a valid hexadecimal number
    ok2 = all(i -> !isnull(tryparse(Int, i, 16)), t)

    return ok1 && ok2
end

C# 196 bytes
using System.Linq;class P{bool T(string v){var r=v.Length==36;for(var i=0;i<v.Length;i++)r&=new[]{8,13,18,23}.Any(t=>t==i)?v[i]=='-':v[i]>47&&v[i]<58|v[i]>64&&v[i]<71|v[i]>96&&v[i]<103;return r;}}

Ungolfed:
using System.Linq;
class P
{
    public bool T(string v)
    {
        var r = v.Length == 36;
        for (var i = 0; i < v.Length; i++)
            r &= new[] { 8, 13, 18, 23 }.Any(t => t == i)
                ? v[i] == '-'
                : v[i] > 47 && v[i] < 58 | v[i] > 64 && v[i] < 71 | v[i] > 96 && v[i] < 103;
        return r;
    }
}

Method T can be invoked with any non-null string and will return true for valid GUID's, false otherwise. This is a constant-time validation; at the cost of three chars you can early-exit the method (change i < v.Length to i < v.Length && r).
Will try to get the bytecount down further later.
I've obviously left out the Guid.ParseExact way because where's the fun in that? Here it is, without much attempt to golf it down further in 86 bytes:
using System;class P{bool T(string v){Guid x;return Guid.TryParseExact(v,"D",out x);}}

Ungolfed:
using System;
class P
{
    bool T(string v)
    {
        Guid x;
        return Guid.TryParseExact(v, "D", out x);
    }
}

Perl 6,  83  67 bytes

# 83 bytes
{
  (
    my@a=.uc.split('-')
  ).map(*.comb)⊆('0'..'9','A'..'F')
&&
  @a».chars~~(8,4,4,4,12)
}

# 67 bytes
{
  (
    $/=.split('-')
  ).map({:16($_)//|()})==5
&&
  $/».chars~~(8,4,4,4,12)
}

( counts do not include newlines or indents as they are not needed )
usage:
# give it a name
my &code = {...}

say map &code, «
  D293DBB2-0801-4E60-9141-78EAB0E298FF
  0FCE98AC-1326-4C79-8EBC-94908DA8B034
  0fce98ac-1326-4c79-8ebc-94908da8b034
  0FCE98ac-1326-4c79-8EBC-94908da8B034
  00000000-1326-4c79-8EBC-94908da8B034
»;
# (True True True True True)

say map &code, «
  0GCE98AC-1326-4C79-8EBC-94908DA8B034
 '0FCE98AC 1326-4C79-8EBC-94908DA8B034'
  0FCE98AC-13264C79-8EBC-94908DA8B034
  0FCE98AC-13264-C79-8EBC-94908DA8B034
  0FCE98ACD-1326-4C79-8EBC-94908DA8B034
  0FCE98AC-1326-4C79-8EBC-94908DA8B034-
  0FCE98AC-1326-4C79-8EBC-94908DA8B034-123
»;
# (False False False False False False False)

Python 2, 99 112 bytes
def f(u):
 try:u=u.split()[0];int(u.replace('-',''),16);print[8,4,4,4,12]==map(len,u.split('-'))
 except:print 0

On a valid input, it prints True. On an invalid input it prints False or 0, depending on why it was invalid. False and 0 are both falsey in Python.
The function has to check 3 things:

Every non-hyphen character is a digit or is in ABCDEF
There are exactly 4 hyphens
There are 8 characters before the first hyphen, 12 after the last, and 4 between any other two

Here's a breakdown to show how it checks for them. It's slightly out of date but I'm hungry so I'll update it later.
def f(u):
    try:
        int(u.replace('-',''),16) # Remove all hyphens from the string and parse what's
                                  # left as a base 16 number. Don't do anything with this
                                  # number, but throw an exception if it can't be done.

        return[8,4,4,4,12]==map(len,u.split('-')) # Split the string at each hyphen and
                                                  # get the length of each resulting
                                                  # string. If the lengths == [8,4,4,4,12],
                                                  # there are the right number of groups
                                                  # with the right lengths, so the string
                                                  # is valid.
    except:
        return 0 # The only way to get here is if the string (minus hyphens) couldn't be
                 # parsed as a base 16 int, so there are non-digit, non-ABCDEF characters
                 # and the string is invalid.

I guess you can save 2 bytes if you replace both instances of return with print. (In which case you'll definitely want to be in Python 2, because print works differently in Python 3.)

This doesn't work in Python 3, because map now returns a "map object", not a list.

This doesn't work in python 2 (probably 3 too) because the int function allows spaces - 0FCE98ac-1326-4c79-8EBC-94908da8B03 with a trailing space. See comment in deleted Pyth answer here if able.

Python 2, 57 bytes
Thank goodness for built-in! - make sure to enclose strings in quotes.
import uuid
try:uuid.UUID(input());print 1
except:print 0

According to the docs you linked to, that would print 1 for input 12345678123456781234567812345678.

if this worked you'd be able to save bytes by doing try:print uuid.UUID(input()) because all that's required is you print a truthy value

This program accepts many UUID formats, but the question wants only the 36-character UUID format, with hyphens.

You could salvage this, coping with the updated rules, by checking if the input string is equal to the uuid converted back to string. Gives you a truthy value right away.

Pyth, 39 bytes
&&!+1xzd.xi:zK\-k16ZqxKc+zK1mid36"8dinz

Try it here.

Your "try it here" link is missing the \ character in K\-k, so it fails to run as is.

That has been fixed now

Python 2, 93 89 85 bytes
lambda u:(set(u)<=set("-0123456789abcdefABCDEF"))*map(len,u.split("-"))==[8,4,4,4,12]

The map() call guarantees that the sections are of the right lengths, and the all() tests each character for being either a hyphen or an arbitrary-case hex digit.  The generator expression is testing each character by iterating through that entire string, so it's not the most performant method, I'm afraid, but it should satisfy the test cases:
>>> f=lambda u:(set(u)<=set("-0123456789abcdefABCDEF"))*map(len,u.split("-"))==[8,4,4,4,12]
>>> testcases = """\
... D293DBB2-0801-4E60-9141-78EAB0E298FF
... 0FCE98AC-1326-4C79-8EBC-94908DA8B034
... 0fce98ac-1326-4c79-8ebc-94908da8b034
... 0FCE98ac-1326-4c79-8EBC-94908da8B034
... 00000000-0000-0000-0000-000000000000""".splitlines()
>>> failcases = """\
... 0GCE98AC-1326-4C79-8EBC-94908DA8B034
... 0FCE98AC 1326-4C79-8EBC-94908DA8B034
... 0FCE98AC-13264C79-8EBC-94908DA8B034
... 0FCE98AC-13264-C79-8EBC-94908DA8B034
... 0FCE98ACD-1326-4C79-8EBC-94908DA8B034
... 0FCE98AC-1326-4C79-8EBC-94908DA8B034-
... 0FCE98AC-1326-4C79-8EBC-94908DA8B034-123
... 00000000-0000-0000-000 -000000000000
... 00000000-0000-0000- 000-000000000000""".splitlines()
>>> all(f(u) for u in testcases)
True
>>> any(f(u) for u in failcases)
False
>>>

Anybody have any idea why the shortest correct Python answer has been downvoted?  Not enough explanation?

Jojodmo -- in case there was confusion about this, I did not reject your proposed change -- I had already made an edit because I had missed the A-F characters (I copied from a window where I was testing negative cases), and Community auto-rejected your proposal without me knowing it had even been raised.  By the time I knew you'd proposed it, @nimi had already made the correction to the heading.
I very much hope that has nothing to do with the downvote, as that would reflect very poorly on this community.  Anyway, I'll assume it's the other thing, and add a bit more explanation.

You can remove the f= and the spaces around the string in the all block.

oh awesome, nice catch -- edited

Strictly speaking, you need to have a print statement in there to get ot to STDOUT

You can save 8 (or 6, you might need to add parenthesis) bytes by converting your all(..) to set inclusion testing: set(u)<=set("-0123456789abcdefABCDEF").

oh, and likely a bit more efficient, nice @MathiasEttinger, i'll update it now

@wnnmaw, i missed a couple of the rules at first, too -- in this case:
"If using a function, instead of using STDOUT, the output can be the return value of the function"

Common Lisp - 161
(lambda(s &aux(u(remove #\- s)))(and(=(length s)36)(=(length u)32)(every(lambda(p)(char=(char s p)#\-))'(8 13 18 23))(ignore-errors(parse-integer u :radix 16))))

The returned value if true is the hash, as a number, which is a useful result to have.
Ungolfed
(defun uuid-p (string &aux (undashed (remove #\- string)))
  (and
   ;; length of input string must be 36
   (= (length string) 36)

   ;; there are exactly 4 dashes
   (= (length undashed) 32)

   ;; We check that we find dashes where expected
   (every (lambda (position)
            (char= (char string position) #\-))
          '(8 13 18 23))

   ;; Finally, we decode the undashed string as a number in base 16,
   ;; but do not throw an exception if this is not possible.
   (ignore-errors
    (parse-integer undashed :radix 16))))

F# 44 characters
fun s->System.Guid.TryParseExact(s,"D")|>fst

In F#, functions with out parameters can be called by omitting the out parameter; its value at return will be combined with the function's true return value into a tuple.
Here, the tuple is piped to the fst function, which returns its first member, which in this case is the Boolean return value of TryParseExact, indicating the success or failure of the call.
As a check for the correct format, we return true only if the string is 36 characters long.
Before I saw RobIII's C# answer, I had not thought of using TryParseExact, so my answer was to have been three characters longer:
fun s->System.Guid.TryParse s|>fst&&s.Length=36

TryParse(string, Guid) accepts input in the following formats:
00000000000000000000000000000000
00000000-0000-0000-0000-000000000000
{00000000-0000-0000-0000-000000000000}
(00000000-0000-0000-0000-000000000000)
{0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}

Of these, only the second is 36 characters long.

SAS, 171 144 141
data;infile stdin;file stdout;input a$9b$14c$19d$24;e=(a!!b!!c!!d='----')*length(_infile_)=36*(1-missing(put(input(compress(_infile_,,'adk'),$hex32.),$hex32.)));put e;run;

Actually uses stdin and stdout - one of the lesser-known features of this particular language. Works for the examples given so far, but possibly not in all cases. Can probably be improved upon.
Better approach - one character at a time:
data;infile stdin;file stdout;do i=1 to 37;input@i c$1.@;a+ifn(i in(9,14,19,24),c='-',n(input(c,hex.))-36*(i>36&c^=''));end;b=a=36;put b;run;

Golfed another 6 characters off the central expression!
Ungolfed:
data;
infile stdin;
file stdout;
do i=1 to 37;
input@i c$1.@;
a+ifn(i in(9,14,19,24),c='-',n(input(c,hex.))-36*(i>36&c^=''));
end;
b=a=36;
put b;
run;

This generates quite a few warnings and notes in the log, but it doesn't print them to stdout or stderr, so I think this is fair game.

C, 391 bytes
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#define F printf("0")
#define T printf("1")
#define E return 0
main(){char s[99],*t;int k=1,l,i;scanf("%99[^\n]",s);if(s[strlen(s)-1]=='-'){F;E;}t=strtok(s,"-");while(t!=NULL){for(i=0,l=0;t[i]!=0;i++,l++){if(!isxdigit(t[i])){F;E;}}if((k==1&&l!=8)||((k>1&&k<5)&&l!=4)||(k==5&&l!=12)){F;E;}k++;t=strtok(NULL,"-");}if(k==6){T;E;};F;}

MATLAB, 126 bytes
function f(a)
b='-';if length(a)==36&&a(9)==b&&a(13)==b&&a(17)==b&&a(21)==b;a(a==b)=[];if any(isnan(hex2dec(a)));0;end;1;end;0

C function, 102
A rule change disallowed my previous c scanf()-based answer, so here's another c answer using isxdigit() which I think should be allowed to compete:
i;f(char *s){for(i=8;i<24;i+=5)s[i]=s[i]-45?1:s[i]+3;for(i=0;isxdigit(s[i]);i++);return i==36&&!s[i];}

Try it online.

Check for - characters (ASCII 45) at the relevant positions - if so, replace them with 0s (ASCII 48 (=45+3))
Walk the string checking each char with isxdigit()
Return TRUE if string length is 36 and final character is NUL.

Python 3, 134 bytes
def a(i):
 try:l=[1+int(k,16)and(len(k)==c)for k,c in zip(i.split("-"),[8,4,4,4,12])];return(len(l)==5)&(0 not in l)
 except:return 0

int(k,16) tries to cast k to a base-16 int. On a character other than 0-9a-fA-F- it fails, in which case we return 0, which is falsy.
Add 1 to that int and we get a guaranteed truthy value - we've stripped away all hyphens with str.split() so we can't get the value -1 and all non-0 ints are truthy.

Batch, 148 139 + 2 = 150 141 bytes
@set/pu=
@for %%d in (1 2 3 4 5 6 7 8 9 A B C D E F)do @set u=!u:%%d=0!
@if -!u!==-00000000-0000-0000-0000-000000000000 exit/b0
@exit/b1

Added 2 bytes because you need to use the /v switch to CMD.EXE.
Exits with ERRORLEVEL 0 on success, 1 on failure.
Edit: Saved some bytes mainly because := is case insensitive but there were other tweaks too.

Java, 345 bytes
interface q{static void main(String[]a){int i=-1;char[]b=a[0].toCharArray();java.io.PrintStream u=System.out;if(b.length>36||b.length<36)u.print(1<0);if(b[8]!='-'||b[13]!='-'||b[18]!='-'||b[23]!='-')u.print(1<0);while(++i='0'&&b[i]<='F')||(b[i]>='a'&&b[i]<='f')))u.print(1<0);}}u.print(1>0);}}

Input is first command line argument. Output is error code(0 means valid UUID, 1 means not valid)
Ungolfed with comments:
interface q {
    static void main(String[] a) {
        int i = -1;                                                             // Index
        char[] b = a[0].toCharArray();                                          // Characters from input
        java.io.PrintStream u = System.out;                                     // STDOUT
        if (b.length > 36||b.length < 36)                                       // If input length is not 36
            u.print(1<0);                                                       // Invalid
        if (b[8]!='-'||b[13]!='-'||b[18]!='-'||b[23]!='-')                      // If hasn't got separators at correct positions
            u.print(1<0);                                                       // Invalid
        while (++i='0'&&b[i]<='F') || (b[i]>='a'&&b[i]<='f') ))     // If incorrect hexadecimal number
                    u.print(1<0);                                               // Invalid
            }
        }
        u.print(1>0);                                                           // Valid
    }
}

EDIT: Didn't notice the STDOUT part. Oops, fixed now.

Nice! You can replace if(b.length>36||b.length<36) with simply if(b.length!=36). Also, because you can print truthy values, you could simply print 0 instead of 1<0, and 1 instead of 1>0.

@Jojodmo Based on the votes, a truthy value is in the form of if(truthy_value){ doSomethingOnYes(); } else{ doSomethingOnFalse(); } So in Java a boolean is a truthy value, but 1 or 0 isn't. Only when the OP of a challenge says something like: "Your output can be true/false, 0/1, empty/non-empty; as long as you specify what you use." then you can indeed use 0 and 1 instead of true/false as truthy/falsey value.

As for golfing tips for cookie: @Jojodmo is indeed right with replacing it for if(b.length!=36); || can be | on multiple places, as well as && to &; if(...!='-') can be if(...!=45); int i=-1; ... while(++i<b.length){ can be replaced with for(int i=-1;++i<b.length;){; 'F' can be 70 ('f' could be 102, but that doesn't matter since it's the same byte-count). I like how you've used java.io.PrintStream u=System.out; btw, I should remember that one! So thanks.

PHP, 109 Bytes
prints 1 for true and 0 for false
for($t=($l=strlen($a=$argn))==36;$i<$l;$i++)$t*=$i>7&$i<24&!($i%5-3)?$a[$i]=="-":ctype_xdigit($a[$i]);echo$t;

$i>7&$i<24&!($i%5-3) is 5 Bytes shorter then in_array($i,[8,13,18,23])
112 Bytes
echo array_filter(str_split($argn),function($i){return!ctype_xdigit($i);})==[8=>"-",13=>"-",18=>"-",23=>"-"]?:0;

113 Bytes
echo array_diff(str_split(strtolower($argn)),array_map(dechex,range(0,15)))==[8=>"-",13=>"-",18=>"-",23=>"-"]?:0;

Swift 3, 50 bytes
Pass in a string s
import Foundation
print(UUID(uuidString:s) != nil)

Vyxal, 167 bitsv2, 20.875 bytes
ɽ\-€:@»S₌»f4*⁼ßk6vF¤J≈

Try it Online!
Bitstring:
00100110000000110100100100111101001111011101001010000101101010001100111010011110101100110110111011000100010111110110101000111001111000100010111010111000111011100101010

ɽ\-€:@»S₌»f4*⁼ßk6vF¤J≈
ɽ\-€:                   # to lowercase, split on "-" and push two copies to the stack
     @       ⁼          # does the vectorized length equal
      »S₌»              # the compressed number 21113
          f4*           # as a list of digits each multiplied by 4
              ßk6vF     # if so, remove all of the characters that are in the string "0123456789abcdef"
# This is NOT regex, vyxal has regex elements
                   ¤J≈  # append an empty string and check if all elements are equal

Created with the help of Luminespire.

Java, 172 bytes 168 bytes (Thanks Wheat Wizard)
Kinda cheaty since I used java.util.UUID, but here goes:
import java.util.UUID;class ValidUUID{public static void main(String[] a){try{UUID.fromString(a[0]);System.out.println(1);}catch(Exception e){System.out.println(0);}}}

Ungolfed version:
import java.util.UUID;

class ValidUUID {

    public static void main(String[] a) {
        try {
            UUID.fromString(a[0]);
            System.out.println(1);
        } catch(Exception e) {System.out.println(0);}
    }
}

Welcome to the site!  I think you can remove the space between try and {.

@WheatWizard thank you :D also noticed I can remove the " around 0 and 1

You should be able to remove the space between String[] and a. Also, you should be able to replace println with print.

Class name can be 1 character. You can use java.util.UUID.fromString instead of importing.

AWK, 98 bytes
BEGIN{FS=""}{for(j=4;k<NF;){h+=(j+=5)<25?$j=="-":0
s+=strtonum("0x"$++k 1)>0}$0=h+s==36&&NF==36}1

Simply splits the line at every character and checks if each character is a hex digit and that there are hyphens at the appropriate places.  strtonum converts invalid characters to 0.  Making the comparison between 0 and m (and arbitrarily chosen invalid character) require additional steps. Luckily 01 is a valid hex number, but m1 is not.
Initially I wrote two for loops, but I saved 1 byte by squeezing them together. :)
NOTE: GAWK can read input as hex numbers, but this requires a very long command line option.

Python 2, 41 bytes
from uuid import*;lambda a:UUID(a).hex==a

Python has a builtin module for handling UUIDs.

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

all_licenses: 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/