text:
Mirror programs
Here is your task, should you choose to accept it: Output (through STDOUT, or whatever is most convenient) some n by m ASCII art that has at least one line of symmetry and is non-empty. Example:
HiiH
iooi
iooi
H!!H

This is a 4x4 example output.
(Note: I define an ASCII character to be in the ASCII range 32-126 plus newlines and spaces. No tabulators.)
Here's the catch: Your program must also reflect across these same axes AND must be a rectangle in shape. (The output and the input are not necessarily the same width/length). Here is an example in JavaScript:
console.log("HiH")//("HiH")gol.elosnoc;
console.log("JvJ")//("JvJ")gol.elosnoc;
console.log("...")//("...")gol.elosnoc;

The source code has one line of symmetry (vertical) and the output has one line of symmetry: vertical.
HiH
JvJ
...

This is a popularity-contest, so the highest-voted answer on THIS DATE:
3:00 PM
Saturday, September 27, 2015
Eastern Time (ET)

will be the winner.
TL;DR
Write a program with the same axes of reflections as the output, of which is at least one. The output must have side lengths greater than one and must have at least one non-whitespace character.
EDIT
If a character has a mirrored version (e.g. ( and )), then it should be used instead of itself. Example:
[>Hello!\} => {/!olleH<]

Why this question is not a duplicate
Said question wished to produce a quine which was the same, forth and back; my challenge is different in two ways. One, it does not necessarily have to be forth and back (up and down, right and left, e.g.). Two, I am not asking for a quine.

A square always has the "same width". You mean rectangle.

@minxomat Yes, I do. Lemme edit that.

Is there a minimum value for n and m?

@Cole It says greater than one.

@minxomat Oh silly me, I read everything but the TL;DR. Thanks.

Would the downvoter care to explain why he/she downvoted? I'd love to improve.

@CᴏɴᴏʀO'Bʀɪᴇɴ I didn't downvote but it probably happened because someone thinks the pop-con tag here makes it too subjective.

@CᴏɴᴏʀO'Bʀɪᴇɴ Most likely because [tag:popularity-contest] is not very ... popular. But it is refreshing to see something else than codegolf.

@Calvin'sHobbies Oh, I see. Is it too subjective?

Your Javascript example shows the reflection of ( as ), but the reflection of c is still c. Is that intended?

@GregHewgill Yes, let me clarify.

Can I make the code a one-liner, as long as it is horizontally symmetrical?

/pqdb\  have mirrored versions. and some would say `'``

I think this challenge is too broad to be interesting. What exactly should voters take into account when choosing their favorite answer?

I don't think this adds much to Shortest Mirror Quine Challenge

Your first example is wrong, you should use ! instead of is in two bottom rows, and the second example should be console.log("HiH")//\\("HiH")gol.elosnoc; etc.

@Voitcus Sorry -- my mistake.

Brainfuck, 103 bytes
I made you a sandwich.
---+++++++++++++---
[>+++>+<<->>+<+++<]
>...>-.<...>.-<...<
[>+++>+<<->>+<+++<]
---+++++++++++++---

Output:
***
***
***

Doesn't it say in the question: Write a program with the same axes of reflections as the output, of which is at least one. The output must have side lengths greater than one and must have at least one non-whitespace character.

Ah, yes, in the TL;DR rather than the main body of the question.  Time to fix this up!

+1 for the sandwich :D Also, good strategy to modify cells without printing.

Pyth, 29 bytes
FG[\@\@)pGpG*0"0*GqGq(@/@/]GF

Demo
I'm assuming that one-liners are okay, otherwise there is an easy fix.

+1, but shouldn't those ps be mirrored as qs?  :-P

They could be, not that it changes anything. I'll change it anyway :D


text:
Generate random UUID
I need a UUID. Your job is to generate one.
The canonical UUID (Universally Unique IDentifier) is a 32 digit hexadecimal number with hyphens inserted in certain points.The program should output 32 hex digits (128 bits), in the form of xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12 digits), where x is a random hexadecimal number. Assuming that your language's PRNG is perfect, all valid outputs must have the same probability of being generated.
TL;DR
Generate 32 random hexadecimal digits in the  form 8-4-4-4-12 digits. Shortest code wins.
EDIT: Must be hexadecimal. Always generating decimal only is invalid.
EDIT 2: No built-ins. These aren't GUIDs, just generic hex digits.

Example output:
ab13901d-5e93-1c7d-49c7-f1d67ef09198
7f7314ca-3504-3860-236b-cface7891277
dbf88932-70c7-9ae7-b9a4-f3df1740fc9c
c3f5e449-6d8c-afe3-acc9-47ef50e7e7ae
e9a77b51-6e20-79bd-3ee9-1566a95d9ef7
7b10e43c-3c57-48ed-a72a-f2b838d8374b

Input, and standard loopholes are disallowed.

This is code-golf, so shortest code wins.
Also, feel free to ask for clarifications.

To be clear, we should print one randomly generated UUID, yes?

Seems like a less strict version of http://codegolf.stackexchange.com/q/32309/14215

@Dennis: correct.

@Geobits: true, but not a duplicate :P

"These examples are not random. Try to attach some significance." What does that mean?

I don't think this is a duplicate. Sure, the intended output is strikingly similar, but all answers from Generate four type-4 GUIDs for me only use 448 bits of entropy.

@AlexA. I took the idea from here

Actually, one does not need hexadecimal numbers, 10-base can also be random. For example, 12345678-1234-1234-1234-123456789012 should be a valid UUID (or is any hex digit necessary?). Do you consider this a loophole?

The title and first sentence suggest that you want a canonical UUID, and the examples given appear to follow the spec for UUIDs, but you actually seem to be asking for something else.

The required format user version 1 to version 5 and invalid formats for a UUID. Please, read about version 4 and decide what you want.

I feel compelled to point out that the version 4 (random) UUID has a required format of xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx  where y is one of [89AB].  At the time of this comment, none of the answers (except C# using a built in library) are guaranteed to produce a valid random UUID (and actually, are quite likely to not produce one).

This challenge isn't specifically for any version of UUIDs, but just generating a generic 8-4-4-4-12 string. The output strings look to be UUIDv4 but there's already a UUIDv4 challenge.

@Voitcus It could be a loophole, but I specified in the question that it should be in hexadecimal.

@ConfusedMr_C I can add a letter A at the end of the output string and there will be hexadecimal digit. In my opinion your question is not clear.

I'd suggest the following wording: Assuming that your language's PRNG is perfect, all valid outputs must have the same probability of being generated.

Ooh, thanks! :D I'll use that.

Pyth, 20 bytes
j\-msm.HO16*4hdj83 3

Demonstration.
Encodes [1, 0, 0, 0, 2] as 83 in base 3, then adds one and multiplies by four to get the length of each segment. Then makes hex digits and joins on hyphens.

CJam, 26 25 bytes
8 4__C]{{Gmr"%x"e%}*'-}/;

Try it online in the CJam interpreter.
How it works
8 4__C]{              }/   For each I in [8 4 4 4 12]:
        {         }*         Do I times:
         Gmr                   Pseudo-randomly select an integer between 0 and 15.
            "%x"e%             Apply hexadecimal string formatting.
                    '-       Push a hyphen-minus.
                        ;  Discard the last hyphen-minus.

Julia, 80 bytes
h=hex(rand(Uint128),32)
print(h[1:8]"-"h[9:12]"-"h[13:16]"-"h[17:20]"-"h[21:32])

Generate a random 128-bit integer, get its hexidecimal representation as a string padded to 32 digits, and divide that into segments joined with dashes.
Thanks to ConfusedMr_C and kvill for their help!

Perl 5, 43 bytes
Saved 2 bytes thanks to @Xcali!
printf"%04x"."-"x/[2-5]/,rand 2**16for 1..8

Try it online!

Shaved two bytes, still using your basic method: Try it online!

PowerShell, 77 69 67 bytes
((8,4,4,4,12)|%{((1..$_)|%{'{0:X}'-f(random(16))})-Join""})-Join"-"

edit: extraneous parens:
((8,4,4,4,12)|%{((1..$_)|%{('{0:X}'-f(random(16)))})-Join""})-Join"-"

edit: was able to remove the trailing .Trim("-") from the original:
(((8,4,4,4,12)|%{((1..$_)|%{('{0:X}'-f(random(16)))})+"-"})-Join"").Trim("-")

It may be clearer with some whitespace given the nature of the flags (-f and -Join). I would still like to lose the final Trim("-"):
(((8,4,4,4,12)|%{((1..$_)|%{('{0:X}' -f (random(16)))}) + "-"}) -Join "").Trim("-")

Or, using the built-in functionality (ala the C# answer above)
'{0}'-f[System.Guid]::NewGuid()

However, it seems a wee bit shortcut-y even if it comes in at 31 bytes.

61 byte: (8,4,4,4,12|%{-join(1..$_|%{'{0:X}'-f(random(16))})})-join'-'

(New-Guid).ToString()

Python 2, 86 84 bytes
from random import*;print'-'.join('%%0%ix'%i%randint(0,16**i-1)for i in[8,4,4,4,12])

This chains string formatters to make Python format the hex numbers uniquely for each segment.
Ungolfed:
import random

final = []
for i in [8, 4, 4, 4, 12]:               # Iterate through every segment
    max = (16 ** i) - 1                  # This is the largest number that can be
                                         # represented in i hex digits
    number = random.randint(0, max)      # Choose our random segment
    format_string = '%0' + str(i) + 'x'  # Build a format string to pad it with zeroes
    final.append(format_string % number) # Add it to the list

print '-'.join(final)                    # Join every segment with a hyphen and print

This could use some improvement, but I'm proud.

PHP, 69 72 75 bytes
foreach([8,4,4,4,12]as$c)$r[]=rand(".1e$c","1e$c");echo join('-',$r);

This does not output hex digits (a, ... f). They are allowed, but not required by the question body.
No digit group starts with 0 (also not required).
edit: saved 3 bytes thanks to @IsmaelMiguel

That looks like a bi more than 32 bytes.

@isaacg yes, sorry - my mistake

You should use join() instead.

JavaScript, ES6, 106 bytes
"8-4-4-4-12".replace(/\d+/g, m => {t=0;for(i=0; i<m; i++) {t+=(Math.random()*16|0).toString(16)}return t})

Uses Regex replace. Treats the format string as a count for generating a hex char. Hoisting wherever I can; omitting semicolons where possible.

89 bytes, '8-4-4-4-12'.replace(/\d+/g,n=>Math.floor(16**n*Math.random()).toString(16).padStart(n,0))

C#, 65 Bytes
using System;class C{void Main(){Console.Write(Guid.NewGuid());}}

edit: Yes ! C# is shorter than another Language (besides Java) :)

I think this is considered a standard loophole... :( http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default

I think this is not considered a standard loophole: As you can see the request to abandon this stuff just got 2 upvotes in over 1 year. Contrarily the comment that says you should use built-in-functions got 58 upvotes. Or as one commenter said --> If we were all limited to the same set of built-in functions, every contest would be won by APL or Golfscript because their command names are the shortest. (Michael Stern)

or to just put it another way around: Can we use printf? or should we use inline asm to trigger interupt 21?

A good point! I didn't intend to upset, I only meant to be helpful! I guess then, Mathematica could win with CreateUUID[]!

@StephanSchinkel The "only 2 upvotes in a year" is misleading. It has 47 upvotes and 45 downvotes right now, so a net +2. That being said, the generally accepted threshold is higher than that, so you're right that it doesn't "really" count as a standard loophole right now.

However, does that function give a formatted GUID with certain positions fixed? If so, I don't think it qualifies, since the spec says every x position (32 total) should be random.

Is this valid? The OP edited in "No built-ins. These aren't GUIDs, just generic hex digits."

Don't know who is downvoting me here. Please have a look at when I answered the question. I answered at Revision 3 of the question. Current Revision is 7. No built ins came with Revision 6. 4 days after I have answered the question. But thanks nonetheless :-)

gawk, 86
BEGIN{for(srand();j++<32;printf(j~"^9|13|17|21"?"-":E)"%c",x+(x>10?87:48))x=rand()*16}

You can use this once every second to generate a unique random "UUID". This is because srand() uses the system time in seconds since epoch as argument if there is no argument given.
for n in `seq 100` do awk 'BEGIN{for(srand();j++<32;printf(j~"^9|13|17|21"?"-":E)"%c",x+(x>10?87:48))x=rand()*16}'; sleep 1; done

I think the awk part is rather elegant.
BEGIN{
    srand()
    for(;j++<32;) {
        x=rand()*16
        x+=(x>10?87:48)
        printf "%c", x
        if(j~"^8|12|16|20")printf "-"
    }
}

If you want to use it more often than once every second you can call it in bash like this. Note that the awk part is changed too.
echo `awk 'BEGIN{for(srand('$RANDOM');j++<32;printf(j~"^9|13|17|21"?"-":E)"%c",x+(x>10?87:48))x=rand()*16}'`

The echo is added there to print a new line every time.

K5, 35 bytes
"-"/(0,8+4*!4)_32?`c$(48+!10),65+!6

To generate a hex alphabet I generate a character string (`c$) from a list of digits (48+!10) and the first 6 capital letters (65+!6). An alternate way of generating the digits which is the same length is ,/$!10.
With the string "0123456789ABCDEF" generated, the rest is simple. Select 32 random values from this set (32?), slice (_) the resulting string at 0 8 12 16 20 computed via (0,8+4*!4), and then join the resulting string fragments with dashes ("-"/).
In action:
  "-"/(0,8+4*!4)_32?`c$(48+!10),65+!6
"9550E114-A8DA-9533-1B67-5E1857F355E1"

R, 63 bytes
x=sample(c(0:9,letters[1:6]),36,1);x[0:3*5+9]='-';cat(x,sep='')

Try it online!
The code first builds a 36 character random string, and then places the four hyphens. It outputs a UUID to stdout.

Replace the c call with sprintf("%x",0:15) for -1.

Perl 6, 53 bytes
The obvious one:
say join '-',(0..9,'a'..'f').flat.roll(32).rotor(8,4,4,4,12)».join # 67

Translating the Perl 5 example using printf, results in code that is a bit shorter.
printf ($_='%04x')~"$_-"x 4~$_ x 3,(0..^4⁸).roll(8) # 53

(0..16⁴)?! You can do that in Perl?

@VoteToSpam You can as of 9 days ago. ( Perl 6 will be released later this month )

Cooooool.  Maybe I should learn it

@VoteToSpam That's nothing compared to 1,2,4,8,16 ... * which generates a lazy infinite list of the powers of 2. ( {2**$++} ... * also works )

Kotlin, 175 bytes
fun main(a:Array<String>){
fun f()="0123456789abcdef".get((Math.random()*16).toInt())
var s=""
for(i in listOf(8,4,4,4,12)){
for(j in 1..i)
s+=f()
if(i!=12)s+="-"}
println(s)}

Try it online!
My first ever Kotlin program & PPCG submission

152 bytes -> https://tio.run/##JY6xDoJAEER7vsLQsGv04iEiGDSxtDAWfsEqHF7kDnKuhSF8@4mSaV4xeTPPlhttvVdvO1OA@85pyxCuZLxONuk2y@l2LysVirpigDPxQziyZWsA5zJFwe1p7CNi8DMY0hZod3SOPsWVR1d9wL7RL74oyBbJPzJGYajrQQqheeJxegi0As1FjtOHaBnhMHj/BQ

APL (Dyalog Unicode), 115 78 bytes
a←⊣,'-',⊢
H←⊃∘(⎕D,819⌶⎕A)¨16∘⊥⍣¯1
(H 8?16)a(H 4?16)a(H 4?16)a(H 4?16)a H 12?16

Try it online!
This is my first APL submission.
Huge thanks to @Adám for bearing with me at the PPCG's APL chat and for the hexadecimal conversion function.
Thanks to @Zacharý for 1 byte
Edited to fix byte count.

You can assume ⎕IO←0 at no byte cost, Adám does that alot. Also, most bytes (IIRC, all the ones you have here) can be counted as one in APL.

@Zacharý I've used TIO to count the bytes for my submission, should I have used the number of characters instead? I'm still new to PPCG and using APL, so I don't have much actual knowledge of how to do the byte count for it.

Also, you can change a(H 12?16) to a H 12?16 to save one byte.

'-'@(+\9,3⍴5)⊢(⎕D,819⌶⎕A)[?36⍴16] or '-'@(+\9,3⍴5)∊⌂hex?18⍴256

Japt, 32 bytes
[8,4,4,4,12]m@MqG**X sG ù0X} q"-

Try it online!

Welcome to PPCG and welcome to Japt :) I'll take a run through your solutions so far when I can make some time (just back from holidays, so much to catch up on) but the first tip I'll offer is to familiarise yourself with the Unicode shortcuts (m@ - £, for example) and, to help get you started here's a hastily golfed 24 byte version of your solution: https://ethproductions.github.io/japt/?v=1.4.6&code=I+4wMTbsRCCjTXFHcFgpc0cg+TBYw3Et&input= Drop into the Japt chatroom if you've any questions.

Go, 119 110 bytes
import(."math/rand";."fmt")
func f(){for j:=0;j<32;j++{if j>4&&j<24&&j%4<1{Print("-")}
Printf("%x",Int()%16)}}

Try it online!

-9 by @The Thonnu

110 bytes

Julia, 57,60 55 bytes
!n=bytes2hex(rand(UInt8,n))
join(.![4,2,2,2,6],-)|>show

57->60 a mistake
60->55 by @MarcMush and the broadcasting :-)

Attempt This Online!

i think that it is not legal because of using the built-in bytes2hex...

I think that's fine, they didn't really specify what built-ins are disallowed and it's often hard to draw a line. More recent challenges don't tend to have these arbitrary limitations

join(.![4,2,2,2,6],-) will save some bytes

MATLAB/Octave , 95 bytes
a='-';b=strcat(dec2hex(randi(16,32,1)-1)');[b(1:8) a b(9:12) a b(13:16) a b(17:20) a b(21:32)]

Perl, 51 bytes
say"xx-x-x-x-xxx"=~s/x/sprintf"%04x",rand 65536/reg

Requires perl5 >= 5.10 I think. For the /r modifier and for say().

Nice! That's much better than mine! Having looked at your solution, you might even be able to save more based on this meta post with s//xx-x-x-x-xxx/;s/x/sprintf"%04x",rand 65536/eg using -p flag, would also mean it works on older versions without -E.

Thanks. Your suggestion is:
echo|perl -pe's//xx-x-x-x-xxx/;s/x/sprintf"%04x",rand 65536/eg'
And thats just 48 chars between ' '. (Is this kind of cheating? Maybe not)

According to this meta post it's acceptable, I haven't had an opportunity to utilise that mechanism myself yet, but hopefully I will soon enough! Would be 49 bytes (+ -p) but still pretty good and I wouldn't have considered that approach without seeing your answer!

C++, 194 193 221 210 201 bytes
+7 bytes thanks to Zacharý ( detected a - that should not be at the end )
#include<iostream>
#include<random>
#include<ctime>
#define L(a)for(int i=0;i<a;++i)std::cout<<"0123456789abcdef"[rand()%16];
#define P(a)printf("-");L(a)
void t(){srand(time(0));L(8)P(4)P(4)P(4)P(12)}

If someone has a way to get a different value every execution without changing srand and without including <ctime>, that would be great

Can't #define L(a) for ... be #define L(a)for...? (Might have already asked that)

This is invalid, there's a "-" at the end (which there shouldn't be)

@Zacharý Correction applied now

210 bytes

Could you do something like "0123456789abcdef"[rand()%16], and then remove f?

You could save one byte by changing L(a) to ;for(...)..., P(a) to printf("-")L(a), then remove the semicolon before L(8).

I'm not entirely sure if these apply to C++ as well as C, but... you can have the defines in compiler -D... instructions, saving you a whopping 12 bytes total. Also, instead of rand(), you can use clock() to avoid seeding and to get a reasonable degree of randomness, saving you 13 bytes. Furthermore, puts() is 2 bytes shorter than printf(), and using putchar() instead of cout would save you another 2. Total bytes saved: 29.

173 bytes

J, 42 39 37 27 bytes
echo'-'(8+5*i.4)},hfd?36#16

Try it online!

JavaScript REPL, 79 bytes
'66-6-6-6-666'.replace(/6/g,_=>(Math.random().toString(16)+'00000').slice(2,6))

Try it online!
Math.random may return 0. Adding 5 zeros make the slicing get 4 0s

Befunge-93, 97 bytes
v>4448v,+<    <
0*    :  >59*0^
62v0-1_$:|>*6+^
>^>41v < @^99<
v<*2\_$:54+` |
?0>+\1-^ v*68<>
>1^

Try it online!
I'm sure this can be shrunk, but this is my first try :)

Bash, 67 bytes
for l in 4 2 2 2 6;{ o+=`xxd -p -l$l</dev/random`-;}
echo ${o::-1}

Welcome to PPCG!

C (gcc), 143 110 103 96 94 bytes
Golfed down to 94 bytes thanks to ceilingcat and Jonathan Frech.
(*P)()="\xf\x31À";*z=L"\10\4\4\4\14";main(n){for(;*z;*++z&&putchar(45))for(n=*z;n--;printf("%x",P()&15));}

Try it online!
Explanation:
/*
  P is a pointer to a function.
  The string literal contains actual machine code of the function:

  0F 31     rdtsc
  C3        ret

  0xc3 is the first byte of the UTF-8 representation of the character À
*/
(*P)() = "\xf\61À";

// encode uuid chunk lengths as literal characters
// we use wide characters with 'L' prefix because
// sizeof(wchar_t)==sizeof(int) for 64-bit gcc C on TIO
// so z is actually a zero-terminated string of ints
*z = L"\8\4\4\4\14"

main (n)
{
    for (
        ;

        // loop until we reach the trailing zero
        *z;

        // increase the pointer and dereference it
        *++z
             // and output a hyphen, if the pointer does not point at zero
             && putchar(45)
    )
        // output a random hex string with length pointed at by z
        for (n = *z; n--; printf ("%x", P()&15));
}

Hello and welcome to PPCG! 110 bytes.

@JonathanFrech Thank you! Your version is very impressive!

Suggest *z=L"\27\23\17\vz" instead of *z=L"\10\4\4\4\14" and for(n=32;n--;z+=printf("-%x"+(n!=*z),P()&15)-1) instead of for(;*z;*++z&&putchar(45))for(n=*z;n--;printf("%x",P()&15))

C (gcc),  94   91  86 bytes
main(i){srand(&i);i=803912;for(;i--%16||(i/=16)&&printf("-");printf("%x",rand()%16));}

Try it online!
I would have liked to suggest this version in a comment to Max Yekhlakov (his answer), but unfortunately I do not have the 50 needed reputation points yet, so here is my answer.
803912 is C4448 in hexadecimal, it describes how the output should be formatted (12-4-4-4-8), it is reversed because least significant digits will be read first.

Edits:

saved 3 bytes thanks to Jonathan Frech
saved 5 more bytes by replacing srand(time(0)) with srand(&i)

main(){...;int i= can be main(i){...;i=.

I've been thinking something, apparently srand() accept an unsigned int as its seed parameter. On tio.run, an unsigned int is 4 bytes long but the UUID is 16 bytes long. This means only a tiny fraction of the valid outputs (1/2^12) will be generated, thus my solution (as well as the previous one with time(0)) is not valid. What do you think ?

The OP states Assuming that your language's PRNG is perfect, all valid outputs must have the same probability of being generated.. The seed entropy does not necessarily determine the RNG entropy, though it likely does (did not check the srand() implementation). However, srand() is to my knowledge reasonably uniform, so if the RNG was perfect, it would still be uniform. I therefore think your answer is valid.

Ok, I understand. I could also submit my answer as a function, assuming srand() has already been done, and in this case there will be no doubt. But I'm not sure if this is allowed, other C/C++  submissions all seem to include srand() int the answer (unless it does not use rand())

81 bytes

Forth (gforth), 91 89 bytes
include random.fs
hex
: f 0 4 4 4 8 20 0 do dup i = if + ." -" then 10 random 1 .r loop ;

Try it online!
Explanation
Changes the base to hexadecimal, then outputs numbers/segments of the appropriate length with dashes at specified intervals
Code Explanation
include random.fs          \ include the random module
hex                        \ set the base to hexadecimal
: f                        \ start a new word definition
  0 4 4 4 8                \ enter the intervals to place dashes
  20 0 do                  \ start a counted loop from 0 to 0x20 (32 in decimal)
    dup i =                \ check if we are on a character that needs a dash
    if                     \ if we are
      +                    \ calculate the next character that gets a dash
      ." -"                \ output a dash
    then                   \ end the if block
    f random               \ get a random number between 0x0 and 0xf
    1 .r                   \ output it right-aligned in 1-character space
  loop                     \ end the loop
;                          \ end the word definition

Java with Ten Foot Laser Pole v. 1.06, 126 bytes
String u(){return sj224.tflp.util.StringUtil.replace("aa-a-a-a-aaa","a",s->String.format("%04x",(int)(Math.random()*65536)));}

Tested with version 1.06 of the library, but this should work with any version 1.04 or newer.

Python 3.8 (pre-release), 31 bytes
import uuid;print(uuid.uuid4())

Try it online!
Python has an inbuilt package for this specific task. Enjoy :P

This doesn't follow the spec, since the first number of the third segment is always 4 (plus the questions says No built-ins)

Ahh sorry, I didn't read the question properly. I am very impatient :P. Also, could you help me understand why the 3rd segment always starts with 4? isn't uuid4 supposed to generate a random UUID?

From the comments under the question: UUID has a required format of xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx where y is one of [89AB]. I personally don't know why this is

Lua, 153 bytes
math.randomseed(os.time())a=load"b=({...})[1]return('%0'..b..'x'):format(math.random(0,16^b-1))"print(table.concat({a(8),a(4),a(4),a(4),a(8)..a(4)},"-"))

Try it online!

Tcl, 95 bytes
time {append g [format %x[expr [incr i]%4|$i<7|$i>21?"":"-"] [expr int(rand()*16)]]} 32;puts $g

Try it online!

Tcl, 97 bytes
time {append g [format %x[expr [incr i]%4||$i<7||$i>21?"":"-"] [expr int(rand()*16)]]} 32;puts $g

Try it online!

Tcl, 98 bytes
time {incr i;append g [format %x[expr $i%4||$i<7||$i>21?"":"-"] [expr int(rand()*16)]]} 32;puts $g

Try it online!

Tcl, 101 bytes
time {incr i;append g [format %x[expr !($i%4)&&$i>7&&$i<21?"-":""] [expr int(rand()*16)]]} 32;puts $g

Try it online!
Tcl, 104 bytes
proc D {n\ 4} {time {append g [format %x [expr int(rand()*16)]]} $n;set g}
puts [D 8]-[D]-[D]-[D]-[D 12]

Try it online!

Jelly, 17 bytes
ØhWẋ36X€”-“µÇŒð‘¦

Try it online!

SmileBASIC, 65 62 bytes
DEF G H?"-";:END
DEF H?HEX$(RND(65536),4);
END H G G G G H H H

I created a function to print 4 random hex digits: DEF H?HEX$(RND(65536),4);:END as well as 4 digits with a - after them: DEF G:H?"-";:END. Then it just has to call these functions a bunch of times.

Chip, 109 + 5 = 114 bytes
Requires flags -wc36, causing +5 bytes
!ZZZZZZZZZZZZZZZZZZZZZZ
,-----.,+vv--^----^---z
?]]]--R\acd
?xx+-)\\b
?x+x-)\\c
?^xx\--\d
`-xx]v~\e
f*`)'`-\g

Try it online!
Generates 4 random bits (the four ?'s) and converts to hex digits:

0x0 - 0x9 => 0 - 9
0xa - 0xe => b - f
0xf => a

...a bit unconventional, but it saved me some bytes at no expense to the distribution of outcomes.

As far as I’m aware of, -wc36 is less than 6 bytes.

@TheEmptyStringPhotographer the reason it was 6 is lost to time... perhaps I was including the space before the flags as well, but that's just a guess.

Java, 192 181 bytes
interface T{static int t(){return (int)(Math.random()*65536);}static void main(String[]a){System.out.printf("aa-a-a-a-aaa".replaceAll("a","%04x"),t(),t(),t(),t(),t(),t(),t(),t());}}

Ruby, 51 47 + 14 = 65 61 bytes
Run with ruby -rsecurerandom (+14 bytes)
[8,4,4,4,12].map{|n|SecureRandom.hex n}.join ?-

Returns output

Octave, 106 105 103 99 96 bytes
function[]=f,g=@(l)[48:57,'a':'f'](randi(16,[1 l]));strjoin({g(8),g(4),g(4),g(4),g(12)},'-'),end

Try it Online

Pyth, 34 bytes
VS32 aYO16)s.e?}km*d4r2 6+\-bb.HMY

Try it online!
trying to generate the indexes of where the "-" should go, and doing the replacement in a smaller way than hardcoding was an interesting challenge, and probably the hardest part.
Explanation
VS32 aYO16)                          // for N in range(32), append a random number 0-15 to the list Y
                              .HMY   // convert each number in Y to its Hex equivalent
                 m*d4r2 6            // make an array (of indexes) containing [8 12 16 20]. *4 mapped over (range(2,6) -> [2,3,4,5])
            .e                       // enumerating map on the random hex list. For each digit, index is k and value is b.
              ?}k        +\-bb       // map onto each digit the ternary question "is index k in the array of idexes?"
                                     // if no, replace with b (the value that was already there), if yes replace it with "-b".
           s                         // "".join( ) to make the list into a string

MBASIC, 92 bytes
1 FOR I=1 TO 32:PRINT HEX$(INT(RND*16));:IF I=8 OR I=12 OR I=16 OR I=20 THEN PRINT"-";
2 NEXT

Generates 32 "random" hex digits, adding a hyphen in the appropriate places.
Output:
D36A49D6-85AC-51DC-6D84-3BB1EB1A0816

Pushy, 34 bytes
12N4448s$:Z15U&T)?39+;48+'.;L?45'.

Try it online!

12                                 \ Push 12 to stack
  N                                \ Remove printing delimiter (normally a newline)
   4448s                           \ Push 4448, then split into digits
                                   \ The stack is now [12, 4, 4, 4, 8]
        $                          \ While items left on stack:
         :                         \ (top item) times do:
          Z15U                     \    Push random(0, 15)
              &T)?                 \    If bigger than 10 (a hex digit):
                  39+;             \      Add 39 (offset from ASCII numbers to lowercase)
                      48+          \   Add 48, converting it into the correct character
                         '.        \   Print and pop this character
                           ;L?45'. \ Print a dash ('-'), unless stack is now empty.

05AB1E, 19 18 bytes
ŽΣÌε4*F15ÝΩh}J}'-ý

Outputs in uppercase.
Try it online.
Explanation:
ŽΣÌ                  # Push compressed integer 21113
   ε          }      # Pop and map over each of its digit:
    4*               #  Multiply the current digit by 4
      F     }        #  Pop and loop that many times:
       15Ý           #   Push a list in the range [0,15]
          Ω          #   Pop and pick a random number from it
           h         #   Convert it to hexadecimal
            }J       #  After the inner loop: Join the stack together
               }'-ý '# After the map: join the list with "-"-delimiter together
                     # (after which this string is output implicitly as result)

See this 05AB1E tip of mine (section How to compress large integers?) to understand why ŽΣÌ is 21113.

JavaScript (ES6), 79 bytes
a=>[8,4,4,4,12].map(g=e=>e?(16*Math.random()|0).toString(16)+g(e-1):"").join`-`

The function isn't running for me.

Javascript (ES6) - 102 bytes
UUID v4 compliant
A compaction of broofa's solution on Stackoverflow:
"10000000-1000-4000-8000-100000000000".replace(/[018]/g,s=>(s^Math.random()*256&15>>s/4).toString(16))

Python 3, 103 bytes
from random import*;print(''.join(hex(randint(2**(i*3),2**(3*i+2)))[2:]+'-'for i in [8,4,4,4,12])[:33])

Try it online!
Is 100% improvable...

Vyxal, 120 bitsv2, 15 bytes
8 4D₆Wk632ƈ∑ẇ\-j

Try it Online!
Explained
8 4D₆Wk632ƈ∑ẇ\-j
8 4D₆W            # Push the list [8, 4, 4, 4, 64] to the stack
      k632ƈ∑      # Push a string of 32 random hex digits
            ẇ     # Wrap into slices of lengths in the first list. The 64 is used as a value to ensure that the last 12 slice is fully captured.
             \-j  # And join on "-"s

Created with the help of Luminespire.

q, 13 bytes
Not sure if it violates "No built-ins." hoever it's not using the built-in method to generate a random GUID which would be rand 0Ng. Generates 16 random bytes and packs them into a guid.
0x0 sv 16?0x0

Example
q)0x0 sv 16?0x0
8e204f8d-5a0b-b188-1131-4ff06efe824d

source: Stack Exchange

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

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

sort: votes


text:
Draw a Houndstooth Pattern
Write a program or function that takes in two positive integers, a width and a height, and draws an ASCII art houndstooth grid pattern with those dimensions using this 25×26 text grid as the base cell:
.......#.....#####.......
.......##.....#####......
.......###.....#####.....
.......####.....####.....
.......#####.....###.....
.......######.....##.....
.......#######.....#.....
.......########..........
####################.....
.####################....
..####################...
...####################..
....####################.
.....####################
#.....##############.####
##.....#############..###
###....#############...##
####...#############....#
#####..#############.....
.#####.#############.....
..##################.....
........#####............
.........#####...........
..........#####..........
...........#####.........
............#####........

So if the input was 2,1 the output would be:
.......#.....#####..............#.....#####.......
.......##.....#####.............##.....#####......
.......###.....#####............###.....#####.....
.......####.....####............####.....####.....
.......#####.....###............#####.....###.....
.......######.....##............######.....##.....
.......#######.....#............#######.....#.....
.......########.................########..........
####################.....####################.....
.####################.....####################....
..####################.....####################...
...####################.....####################..
....####################.....####################.
.....####################.....####################
#.....##############.#####.....##############.####
##.....#############..#####.....#############..###
###....#############...#####....#############...##
####...#############....#####...#############....#
#####..#############.....#####..#############.....
.#####.#############......#####.#############.....
..##################.......##################.....
........#####....................#####............
.........#####....................#####...........
..........#####....................#####..........
...........#####....................#####.........
............#####....................#####........

And if the input was 5,4 the output would be:
.......#.....#####..............#.....#####..............#.....#####..............#.....#####..............#.....#####.......
.......##.....#####.............##.....#####.............##.....#####.............##.....#####.............##.....#####......
.......###.....#####............###.....#####............###.....#####............###.....#####............###.....#####.....
.......####.....####............####.....####............####.....####............####.....####............####.....####.....
.......#####.....###............#####.....###............#####.....###............#####.....###............#####.....###.....
.......######.....##............######.....##............######.....##............######.....##............######.....##.....
.......#######.....#............#######.....#............#######.....#............#######.....#............#######.....#.....
.......########.................########.................########.................########.................########..........
####################.....####################.....####################.....####################.....####################.....
.####################.....####################.....####################.....####################.....####################....
..####################.....####################.....####################.....####################.....####################...
...####################.....####################.....####################.....####################.....####################..
....####################.....####################.....####################.....####################.....####################.
.....####################.....####################.....####################.....####################.....####################
#.....##############.#####.....##############.#####.....##############.#####.....##############.#####.....##############.####
##.....#############..#####.....#############..#####.....#############..#####.....#############..#####.....#############..###
###....#############...#####....#############...#####....#############...#####....#############...#####....#############...##
####...#############....#####...#############....#####...#############....#####...#############....#####...#############....#
#####..#############.....#####..#############.....#####..#############.....#####..#############.....#####..#############.....
.#####.#############......#####.#############......#####.#############......#####.#############......#####.#############.....
..##################.......##################.......##################.......##################.......##################.....
........#####....................#####....................#####....................#####....................#####............
.........#####....................#####....................#####....................#####....................#####...........
..........#####....................#####....................#####....................#####....................#####..........
...........#####....................#####....................#####....................#####....................#####.........
............#####....................#####....................#####....................#####....................#####........
.......#.....#####..............#.....#####..............#.....#####..............#.....#####..............#.....#####.......
.......##.....#####.............##.....#####.............##.....#####.............##.....#####.............##.....#####......
.......###.....#####............###.....#####............###.....#####............###.....#####............###.....#####.....
.......####.....####............####.....####............####.....####............####.....####............####.....####.....
.......#####.....###............#####.....###............#####.....###............#####.....###............#####.....###.....
.......######.....##............######.....##............######.....##............######.....##............######.....##.....
.......#######.....#............#######.....#............#######.....#............#######.....#............#######.....#.....
.......########.................########.................########.................########.................########..........
####################.....####################.....####################.....####################.....####################.....
.####################.....####################.....####################.....####################.....####################....
..####################.....####################.....####################.....####################.....####################...
...####################.....####################.....####################.....####################.....####################..
....####################.....####################.....####################.....####################.....####################.
.....####################.....####################.....####################.....####################.....####################
#.....##############.#####.....##############.#####.....##############.#####.....##############.#####.....##############.####
##.....#############..#####.....#############..#####.....#############..#####.....#############..#####.....#############..###
###....#############...#####....#############...#####....#############...#####....#############...#####....#############...##
####...#############....#####...#############....#####...#############....#####...#############....#####...#############....#
#####..#############.....#####..#############.....#####..#############.....#####..#############.....#####..#############.....
.#####.#############......#####.#############......#####.#############......#####.#############......#####.#############.....
..##################.......##################.......##################.......##################.......##################.....
........#####....................#####....................#####....................#####....................#####............
.........#####....................#####....................#####....................#####....................#####...........
..........#####....................#####....................#####....................#####....................#####..........
...........#####....................#####....................#####....................#####....................#####.........
............#####....................#####....................#####....................#####....................#####........
.......#.....#####..............#.....#####..............#.....#####..............#.....#####..............#.....#####.......
.......##.....#####.............##.....#####.............##.....#####.............##.....#####.............##.....#####......
.......###.....#####............###.....#####............###.....#####............###.....#####............###.....#####.....
.......####.....####............####.....####............####.....####............####.....####............####.....####.....
.......#####.....###............#####.....###............#####.....###............#####.....###............#####.....###.....
.......######.....##............######.....##............######.....##............######.....##............######.....##.....
.......#######.....#............#######.....#............#######.....#............#######.....#............#######.....#.....
.......########.................########.................########.................########.................########..........
####################.....####################.....####################.....####################.....####################.....
.####################.....####################.....####################.....####################.....####################....
..####################.....####################.....####################.....####################.....####################...
...####################.....####################.....####################.....####################.....####################..
....####################.....####################.....####################.....####################.....####################.
.....####################.....####################.....####################.....####################.....####################
#.....##############.#####.....##############.#####.....##############.#####.....##############.#####.....##############.####
##.....#############..#####.....#############..#####.....#############..#####.....#############..#####.....#############..###
###....#############...#####....#############...#####....#############...#####....#############...#####....#############...##
####...#############....#####...#############....#####...#############....#####...#############....#####...#############....#
#####..#############.....#####..#############.....#####..#############.....#####..#############.....#####..#############.....
.#####.#############......#####.#############......#####.#############......#####.#############......#####.#############.....
..##################.......##################.......##################.......##################.......##################.....
........#####....................#####....................#####....................#####....................#####............
.........#####....................#####....................#####....................#####....................#####...........
..........#####....................#####....................#####....................#####....................#####..........
...........#####....................#####....................#####....................#####....................#####.........
............#####....................#####....................#####....................#####....................#####........
.......#.....#####..............#.....#####..............#.....#####..............#.....#####..............#.....#####.......
.......##.....#####.............##.....#####.............##.....#####.............##.....#####.............##.....#####......
.......###.....#####............###.....#####............###.....#####............###.....#####............###.....#####.....
.......####.....####............####.....####............####.....####............####.....####............####.....####.....
.......#####.....###............#####.....###............#####.....###............#####.....###............#####.....###.....
.......######.....##............######.....##............######.....##............######.....##............######.....##.....
.......#######.....#............#######.....#............#######.....#............#######.....#............#######.....#.....
.......########.................########.................########.................########.................########..........
####################.....####################.....####################.....####################.....####################.....
.####################.....####################.....####################.....####################.....####################....
..####################.....####################.....####################.....####################.....####################...
...####################.....####################.....####################.....####################.....####################..
....####################.....####################.....####################.....####################.....####################.
.....####################.....####################.....####################.....####################.....####################
#.....##############.#####.....##############.#####.....##############.#####.....##############.#####.....##############.####
##.....#############..#####.....#############..#####.....#############..#####.....#############..#####.....#############..###
###....#############...#####....#############...#####....#############...#####....#############...#####....#############...##
####...#############....#####...#############....#####...#############....#####...#############....#####...#############....#
#####..#############.....#####..#############.....#####..#############.....#####..#############.....#####..#############.....
.#####.#############......#####.#############......#####.#############......#####.#############......#####.#############.....
..##################.......##################.......##################.......##################.......##################.....
........#####....................#####....................#####....................#####....................#####............
.........#####....................#####....................#####....................#####....................#####...........
..........#####....................#####....................#####....................#####....................#####..........
...........#####....................#####....................#####....................#####....................#####.........
............#####....................#####....................#####....................#####....................#####........

The width argument must come first. Any reasonable input format (e.g. w,h, w h, (w, h)) is fine.
Print or return the result with an optional trailing newline.
You may use any two distinct printable ASCII characters in place of . and #.
You can translate the base cell vertically or horizontally, as if it had periodic boundary conditions. Thus the top left corner of the output will not necessarily be a 7×8 rectangle of .'s. (New rule!)

The shortest code in bytes wins.
As a bonus, generate an image instead where each . is a pixel of one color and each # is a pixel of another color.

What kind of bonus? A cookie..? ;-)

Screw your "shortest code wins", I'm Befunge'ing this!

@ZachGates Maybe a dog biscuit.

Roll Tide to that!

Pyth, 61 60 55 49 bytes
j*vwmjk*Qd++Rm012Jmms}k++Rhd5U-d4T=T13+Lm1T_mP_dJ

Try it online: Demonstration
edit 1: Combine the two statements generating the band and the triangle (see below)
edit 2: Didn't saw that we can use any symbols. Saved 5 bytes
edit
edit 3: @Calvin'sHobbies allowed translating the base image. Since my approach was based on this idea, this helped quite a lot. -6 bytes
And for the Cookie bonus:
.w*vw*RQ++Rm012Jmm*K255}k++Rhd5U-d4T=T13+LmKT_mP_dJ

This is only 2 bytes longer (51 bytes) and generates the file o.png. For the input 5\n4 it generates the following picture:

Explanation:
The Houndstooth Pattern looks really quite irregular. But if we bring the left 7 columns to the right and the top 5 rows to the botton we get a much nicer pattern:
.#####...................
..#####..................
...#####.................
....#####................
.....#####...............
#.....#####..............
##.....#####.............
###.....#####............
####.....####............
#####.....###............
######.....##............
#######.....#............
########.................
#############.....#######
##############.....######
###############.....#####
################.....####
#################.....###
##################.....##
#############.#####.....#
#############..#####.....
#############...#####....
#############....#####...
#############.....#####..
#############......#####.
#############.......#####

First I produce the top-left 13x13 block:
.#####.......
..#####......
...#####.....
....#####....
.....#####...
#.....#####..
##.....#####.
###.....#####
####.....####
#####.....###
######.....##
#######.....#
########.....

There are 2 simple inequalities, that describe the two #-areas. The band can be described by y + 1 <= x <= y + 5 and the triangle can be described by x <= y - 5. I`ve combined these two conditions:
Jmms}k++Rhd5U-d4T=T13
                 =T13   T = 13
 m               T      map each d of [0, 1, ..., 12] to:
                           the list produced by
  m             T          map each k of [0, 1, ..., 12] to:
       +Rhd5                  the list [d+1, d+2, ..., d+5]
      +                       extended by
            U-d4              the list [0, 1, ..., d - 5]
    }k                        test if k is in the list
   s                          and convert the boolean result to 1 or 0
J                       assign this 13x13 block to J

Then +Rm012 adds 12 zeros at the end of each row , to get the upper 25x13 block.
The lower 25x13 block is now really simple:
+Lm1T_mP_dJ
      m   J    map each row d of J to:
       P_d        reverse the row and pop the last element
     _         reverse the order the rows
+Lm1T          add T ones at the beginning of each row.

All now left is to repeating the pattern and print it
j*vwmjk*Qd+upperlower   implicit: Q = first input number
          +upperlower   combine the two blocks to a 25x26 block
    m                   map each row d to:
       *Qd                 repeat d Q times
     jk                    and join to a string
 *vw                    read another number from input and repeat
j                       join by newlines and print

The difference to the Cookie bonus code:

255 instead of 1
instead of mjk*Qd I use *RQ, since I don't want a string
.w saves this 2D-array to file (converts it to png implicitly)

Fantastic explanation!

You clearly mean "bottom 5 rows to the top", it's just a typo. I don't understand why my comment was deleted without action being taken. As a result I'm shy to go and edit your post myself now. All in all, a very good answer and an excellent explanation. I already upvoted it before

@steveverrill Oh, sorry. I thought you wanted to correct my English in the passage, in which I described the transformation back. Fixed it now. Thanks.

CJam, 106 73 71 bytes
0000000: 71 7e 22 04 94 51 af 40 6e 73 b2 68 3a e1 7e 13 f2 a1  q~"..Q.@ns.h:.~...
0000012: 3e 1d de f5 64 9c 6b 0f 27 4c 36 d7 81 3d 30 35 56 f8  >...d.k.'L6..=05V.
0000024: cd e8 cd 7c dc 90 31 59 40 8b 8c 22 32 35 36 62 32 32  ...|..1Y@.."256b22
0000036: 62 41 73 33 39 2a 2e 2a 73 32 35 2f 2a 66 2a 4e 2a     bAs39*.*s25/*f*N*

Prints 1 and 0 instead of . and #. Try it online in the CJam interpreter.
How it works
q~      e# Read and evaluate all input. This pushes W and H.
"…"     e# Push an encoding of run lengths of the characters in the output.
256b22b e# Convert from base 256 to base 22.
As39*   e# Push "10" and repeat it 39 times.
.*      e# Vectorized character repetition; multiply each base 22 digit (run
        e# length) by the corresponding character of "10…10".
s25/    e# Flatten and split into chunks of length 25.
*       e# Repeat the resulting array of rows H times.
f*      e# Repeat each row W times.
N*      e# Join the rows, separating by linefeeds.

Cookie bonus
0000000: 27 50 6f 31 70 71 7e 5d 5f 5b 32 35 5f 29 5d 2e 2a 5c  'Po1pq~]_[25_)].*\
0000012: 7e 22 04 94 51 af 40 6e 73 b2 68 3a e1 7e 13 f2 a1 3e  ~"..Q.@ns.h:.~...>
0000024: 1d de f5 64 9c 6b 0f 27 4c 36 d7 81 3d 30 35 56 f8 cd  ...d.k.'L6..=05V..
0000036: e8 cd 7c dc 90 31 59 40 8b 8c 22 32 35 36 62 32 32 62  ..|..1Y@.."256b22b
0000048: 41 73 33 39 2a 2e 2a 73 32 35 2f 2a 66 2a 73 2b 4e 2a  As39*.*s25/*f*s+N*

prints a Portable BitMap instead of ASCII art.
Below is the output for input 24 13, converted to PNG:

Befunge-93, 2120 1967 bytes
Here's some high quality befunge, with exception-handling for debugging!
&&00p10pv
v       <
    >94+2*20p        v
>00g|   >                v
    @                >10g>0020gv-1:<
                               >:0`|
                     ,       v    $<
                     +        >v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v
 v_$1-:#^_$20g1-20p55^       >|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>"!DAB"....@
 ,:
 >^".......#.....#####......."                                                    <
  ^".......##.....#####......"                                                  <
  ^".......###.....#####....."                                                <
  ^".......####.....####....."                                              <
  ^".......#####.....###....."                                            <
  ^".......######.....##....."                                          <
  ^".......#######.....#....."                                        <
  ^".......########.........."                                      <
  ^"####################....."                                    <
  ^".####################...."                                  <
  ^"..####################..."                                <
  ^"...####################.."                              <
  ^"....####################."                            <
  ^".....####################"                          <
  ^"#.....##############.####"                        <
  ^"##.....#############..###"                      <
  ^"###....#############...##"                    <
  ^"####...#############....#"                  <
  ^"#####..#############....."                <
  ^".#####.#############....."              <
  ^"..##################....."            <
  ^"........#####............"          <
  ^".........#####..........."        <
  ^"..........#####.........."      <
  ^"...........#####........."    <
  ^"............#####........"  <
^                     p00-1g00<

(Obviously, this is still very golfable.  I just wanted to get an answer up here for now)
So, this is made up of different parts.
&&00p10p

This is just the initializer, it takes in the values and stores them
    >94+2*20p
>00g|      >
    @

This section resets the row count, so we can print out another (width) pictures side by side.  94+2* is calculating 26, the number of rows.  Also, if the height is zero, the program will terminate.
>10g

This gets the width on the stack so we know how many to print
0020gv-1:<
     >:0`|
         $

This adds two dummy values to the stack to tell when we've finished an operation, as well as what row (n) we're on.  This then adds n values to the stack
>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v>v
|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>|>"!DAB"....@

                                                    <
                                                  <
                                                <
                                              <
                                            <
                                          <
                                        <
                                      <
                                    <
                                  <
                                <
                              <
                            <
                          <
                        <
                      <
                    <
                  <
                <
              <
            <
          <
        <
      <
    <
  <
<

This is a control section that will to the (26-n) row.  This is the easiest way i could figure out how to do it.
".......#.....#####......."
".......##.....#####......"
".......###.....#####....."
".......####.....####....."
".......#####.....###....."
".......######.....##....."
".......#######.....#....."
".......########.........."
"####################....."
".####################...."
"..####################..."
"...####################.."
"....####################."
".....####################"
"#.....##############.####"
"##.....#############..###"
"###....#############...##"
"####...#############....#"
"#####..#############....."
".#####.#############....."
"..##################....."
"........#####............"
".........#####..........."
"..........#####.........."
"...........#####........."
"............#####........"

This, obviously, is read and will pop whatever row is read onto the stack backwards.  This means when we pop it off, it will print properly.
v_
,:
>^

This will print until the stack hits a 0, which we left on earlier.
1-:#^_

This takes 1 off of the number of the specific line to print, then checks if it's zero or not.  If it's non-zero, we go back to the fourth block of code.
          ,
          +
20g1-20p55^

This subtracts 1 from the row (n), prints a newline, and goes back to block 3
p00-1g00

Once of all of the rows have printed, this subtracts one from the initial height and goes back to block 2.
All the rest of the code is either control flow or stack management.  Writing this mas more than I thought it would be, but I'm satisfied with how it looks.  It's much more golfable, and that will likely remain a project for another day.
2120 -> 1967: trimmed up some lines with a lot of wasted spaces

I golfed it. Not your answer specifically, but I golfed a solution in Befunge!

Perl, 243
(One byte added for the -n switch to fetch input from stdin.)
($w,$h)=split;for(1..$h){print((sprintf("%025b",hex)x$w).$/)foreach qw(20f80 307c0 383e0 3c1e0 3e0e0 3f060 3f820 3fc00 1ffffe0 fffff0 7ffff8 3ffffc 1ffffe fffff 107ffef 183ffe7 1c3ffe3 1e3ffe1 1f3ffe0 fbffe0 7fffe0 1f000 f800 7c00 3e00 1f00)}

This is fairly straightforward — all it does is convert an array of 26 hex numbers to binary and print them out the required number of times.
Example:
Input:
3 2

Output:
000000010000011111000000000000001000001111100000000000000100000111110000000
000000011000001111100000000000001100000111110000000000000110000011111000000
000000011100000111110000000000001110000011111000000000000111000001111100000
000000011110000011110000000000001111000001111000000000000111100000111100000
000000011111000001110000000000001111100000111000000000000111110000011100000
000000011111100000110000000000001111110000011000000000000111111000001100000
000000011111110000010000000000001111111000001000000000000111111100000100000
000000011111111000000000000000001111111100000000000000000111111110000000000
111111111111111111110000011111111111111111111000001111111111111111111100000
011111111111111111111000001111111111111111111100000111111111111111111110000
001111111111111111111100000111111111111111111110000011111111111111111111000
000111111111111111111110000011111111111111111111000001111111111111111111100
000011111111111111111111000001111111111111111111100000111111111111111111110
000001111111111111111111100000111111111111111111110000011111111111111111111
100000111111111111110111110000011111111111111011111000001111111111111101111
110000011111111111110011111000001111111111111001111100000111111111111100111
111000011111111111110001111100001111111111111000111110000111111111111100011
111100011111111111110000111110001111111111111000011111000111111111111100001
111110011111111111110000011111001111111111111000001111100111111111111100000
011111011111111111110000001111101111111111111000000111110111111111111100000
001111111111111111110000000111111111111111111000000011111111111111111100000
000000001111100000000000000000000111110000000000000000000011111000000000000
000000000111110000000000000000000011111000000000000000000001111100000000000
000000000011111000000000000000000001111100000000000000000000111110000000000
000000000001111100000000000000000000111110000000000000000000011111000000000
000000000000111110000000000000000000011111000000000000000000001111100000000
000000010000011111000000000000001000001111100000000000000100000111110000000
000000011000001111100000000000001100000111110000000000000110000011111000000
000000011100000111110000000000001110000011111000000000000111000001111100000
000000011110000011110000000000001111000001111000000000000111100000111100000
000000011111000001110000000000001111100000111000000000000111110000011100000
000000011111100000110000000000001111110000011000000000000111111000001100000
000000011111110000010000000000001111111000001000000000000111111100000100000
000000011111111000000000000000001111111100000000000000000111111110000000000
111111111111111111110000011111111111111111111000001111111111111111111100000
011111111111111111111000001111111111111111111100000111111111111111111110000
001111111111111111111100000111111111111111111110000011111111111111111111000
000111111111111111111110000011111111111111111111000001111111111111111111100
000011111111111111111111000001111111111111111111100000111111111111111111110
000001111111111111111111100000111111111111111111110000011111111111111111111
100000111111111111110111110000011111111111111011111000001111111111111101111
110000011111111111110011111000001111111111111001111100000111111111111100111
111000011111111111110001111100001111111111111000111110000111111111111100011
111100011111111111110000111110001111111111111000011111000111111111111100001
111110011111111111110000011111001111111111111000001111100111111111111100000
011111011111111111110000001111101111111111111000000111110111111111111100000
001111111111111111110000000111111111111111111000000011111111111111111100000
000000001111100000000000000000000111110000000000000000000011111000000000000
000000000111110000000000000000000011111000000000000000000001111100000000000
000000000011111000000000000000000001111100000000000000000000111110000000000
000000000001111100000000000000000000111110000000000000000000011111000000000
000000000000111110000000000000000000011111000000000000000000001111100000000

Rev 1, C, 118 115 bytes
i,x,y;f(w,h){for(i=26*h*(w*=25);i--;i%w||puts(""))x=i%25,y=i/w%26,putchar(((y>x^y>x+5^x>y+4)&y/13==x/13^y/13)+34);}

9 bytes saved due to new rule allowing translation of the cell. 3 bytes saved by use of w*=25. Rest of post remains unchanged.
Rev 0, C, 127 bytes
i,x,y;f(w,h){for(i=650*w*h;i--;i%(25*w)||puts(""))x=(i+20)%25,y=(i/25/w+8)%26,putchar(((y>x^y>x+5^x>y+4)&y/13==x/13^y/13)+34);}

This goes through the characters, printing them one by one. i%(25*w)||puts("") inserts a newline at the end of each line.
My way of viewing the design is similar to Jakube's, but I bring the top 8 rows to the bottom and the 5 right columns to the left to get the following view. In the program this step is "reversed" by +20 and +8 in the expressions for x and y.
"""""####################
#"""""###################
##"""""##################
###"""""#################
####"""""################
#####"""""###############
"#####"""""##############
""#####"""""#############
"""#####""""#############
""""#####"""#############
"""""#####""#############
""""""#####"#############
"""""""##################
"""""""""""""#####"""""""
""""""""""""""#####""""""
"""""""""""""""#####"""""
""""""""""""""""#####""""
"""""""""""""""""#####"""
""""""""""""#"""""#####""
""""""""""""##"""""#####"
""""""""""""###"""""#####
""""""""""""####"""""####
""""""""""""#####"""""###
""""""""""""######"""""##
""""""""""""#######"""""#
""""""""""""########"""""

Apart from the "inversion of colours" it may look very similar, but there is an important difference: the diagonal stripes match up. (note that the original design does not have diagonal symmetry as it measures 25x26.)
The expression ((y>x^y>x+5^x>y+4)^y/13)+34 produces the following, where the various comparison operators produce the stripes, the ^y/13 produces the "colour flip" half way up and the +34 takes the resulting number 0,1 and boosts it to the ASCII range 34,35.
"""""####################
#"""""###################
##"""""##################
###"""""#################
####"""""################
#####"""""###############
"#####"""""##############
""#####"""""#############
"""#####"""""############
""""#####"""""###########
"""""#####"""""##########
""""""#####"""""#########
"""""""#####"""""########
########"""""#####"""""""
#########"""""#####""""""
##########"""""#####"""""
###########"""""#####""""
############"""""#####"""
#############"""""#####""
##############"""""#####"
###############"""""#####
################"""""####
#################"""""###
##################"""""##
###################"""""#
####################"""""

The term &y/13==x/13 evaluates to false=0 in the top right and bottom left quarters, producing the square part of the pattern as shown previously. Note that because the program downcounts, the origin x=y=0 is at bottom right. This is handy as the square of # is 13 characters wide while the square of " is only 12 characters wide.

Befunge-93, 968 bytes
Yes, that's right! A competing Befunge answer!
&:&\00p10p:520pv:g00p02<v  <
    #   p1*45-1_v#:" "  <  v
    |`-1*65:g02$<      ,
    >:" "\39*\p:" "\47 *v
+:"<"\39*\p:"v"\47*\p25^>\p 1
".......#.....#####......."<v
".......##.....#####......"
".......###.....#####....."
".......####.....####....."
".......#####.....###....."
".......######.....##....."
".......#######.....#....."
".......########.........."
"####################....."
".####################...."
"..####################..."
"...####################.."
"....####################."
".....####################"
"#.....##############.####"
"##.....#############..###"
"###....#############...##"
"####...#############....#"
"#####..#############....."
".#####.#############....."
"..##################....."
"........#####............"
".........#####..........."
"..........#####.........."
"...........#####........."
"............#####........"
,,,,,,,,,,,,,,,,,,,,,,,,,  v>
    > 10g1-:10p #v_@
 " " \47*\p5:"<"v>:" "\39*\ p
\*74 \"v":p\*93\<      v,*5 2p

Explanation tomorrow, bed now. I will say, however, that I do clever stuff with moving a couple redirection arrows and I use the wrap-around property quite a bit too. Test it out in this online interpreter.

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


text:
Stack to the Future
Welcome Back to the Future's fans and enthusiastic codegolfers.
Let's begin with this simple statement : Marty arrives in 2015 in one month (On october the 21st !). Therefore I propose we use the time remaining to pay him and the saga the best homage we can.
Task
Marty left for 2015 on October the 26, 1985. Thus, you will have to write 3 code snippets of respective length 10, 26 and 85 in the language of your choice. Once executed, I'd like to see a visual representation of at least one of the 3 following symbols of Back to the Future :
The Delorean

The Logo
as seen here :

Or (since Marty arrives in 2015 in the 2nd movie), the Grays Sports Almanac :

I don't excpect a copy of those images which are just examples. I expect your creatives ways to display one of those symbols from the Back to the Future franchise.
The rules

This is a popularity contest that will stop at the end of the countdown (i.e. october 21st). Highest upvoted answer by then wins.
You have to stick to one language for the three snippets.
The 3 snippets can act separately to produce 3 results or together and produce one bigger result.
You can use any language you'd like, even Piet if you want.
You can of course use a language that have already been used as long as the result clearly differs from the first answer.
The visual representation can be anything you'd like, from ASCII art to producing a JPG file. It can even be an animation if you feel like it.

Additional Information

Refrain from using the standards loopholes
Be creative ! We have seen that we can tweet mathematical art, you can even draw with your CPU so show me the best of your language.

The format of the answer can follow something along the line :
Snipet length 10
some_code;
...

Snippet length 26
some_more_code;

Snippet length 85
some_final_code;
...

Output
The output or a link to the output.

Welcome to PPCG. This question comes under the standard complaint "this is an art contest, not a programming contest" (potentially it's a literature contest in this case.) An example of a narrower question (which would be on topic) would be a code-golf to draw the logo of the Delorean Motor Company (but you would have to specify exactly how it would be drawn.) Writing a good challenge is hard. Feel free to post your challenges in http://meta.codegolf.stackexchange.com/q/2140/15599 for feedback before you post.

@steveverrill I did exactly what you suggested last, I'm waiting for some more feedback on this challenge in order to narrow it properly. Thanks for your comment !


text:
Molecules to Atoms
The Challenge
Write a program that can break down an input chemical formula (see below), and output its respective atoms in the form element: atom-count.

Input
Sample input:
H2O

Your input will always contain at least one element, but no more than ten. Your program should accept inputs that contain parentheses, which may be nested.
Elements in the strings will always match [A-Z][a-z]*, meaning they will always start with an uppercase letter. Numbers will always be single digits.

Output
Sample output (for the above input):
H: 2
O: 1

Your output can be optionally followed by a newline.

Breaking Down Molecules
Numbers to the right of a set of parentheses are distributed to each element inside:
Mg(OH)2

Should output:
Mg: 1
O: 2
H: 2

The same principle applies to individual atoms:
O2

Should output:
O: 2

And also chaining:
Ba(NO2)2

Should output:
Ba: 1
N: 2
O: 4

Testcases
Ba(PO3)2
->
Ba: 1
P: 2
O: 6

C13H18O2
->
C: 13
H: 18
O: 2

K4(ON(SO3)2)2
->
K: 4
O: 14
N: 2
S: 4

(CH3)3COOC(CH3)3
->
C: 8
H: 18
O: 2

(C2H5)2NH
->
C: 4
H: 11
N: 1

Co3(Fe(CN)6)2
->
Co: 3
Fe: 2
C: 12
N: 12

Scoreboard
For your score to appear on the board, it should be in this format:
# Language, Score

Or if you earned a bonus:
# Language, Score (Bytes - Bonus%)

function getURL(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:getURL(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){var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),useData(answers)}})}function getOwnerName(e){return e.owner.display_name}function useData(e){var s=[];e.forEach(function(e){var a=e.body.replace(/<s>.*<\/s>/,"").replace(/.*<\/strike>/,"");console.log(a),VALID_HEAD.test(a)&&s.push({user:getOwnerName(e),language:a.match(VALID_HEAD)[1],score:+a.match(VALID_HEAD)[2],link:e.share_link})}),s.sort(function(e,s){var a=e.score,r=s.score;return a-r}),s.forEach(function(e,s){var a=$("#score-template").html();a=a.replace("{{RANK}}",s+1+"").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SCORE}}",e.score),a=$(a),$("#scores").append(a)})}var QUESTION_ID=58469,ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],answer_ids,answers_hash,answer_page=1;getAnswers();var VALID_HEAD=/<h\d>([^\n,]*)[, ]*(\d+).*<\/h\d>/;
body{text-align:left!important}table thead{font-weight:700}table td{padding:10px 0 0 30px}#scores-cont{padding:10px;width:600px}#scores tr td:first-of-type{padding-left:0}
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Scores

	User	Language	Score

{{RANK}}	{{NAME}}	{{LANGUAGE}}	{{SCORE}}

Edit: Square brackets are no longer a part of the question. Any answers posted before 3AM UTC time, September 23, are safe and will not be affected by this change.

What are the allowed forms of input?

@ZachGates It's better that we're allowed to support either, but keep in mind that square brackets is still incorrect. AFAIK in chemical formulae square brackets are only used to indicated concentration. E.g.: [HCl] = 0.01 mol L^-1.

See the "Examples" section. Is there something specific you're asking about? @Oberon Inputs are denoted by a >.

Could you maybe add some really complex examples for people to test with?

I've just added a few more examples. Currently, only valid chemical formulas are shown in the post. I could perhaps add some non-real examples; just let me know. @orlp

The prompt is needed? Is it enough to process one formula at once? The prompt is '> ' or just '>'?

No, it should handle just one input. The >  format was purely for demonstration. @uno20001

Must the output format be exactly as above? Or are similar formats allowed?

Each element must be in the format element: atom-count followed by a newline. (the format above) @orlp

+1 for a great challenge, but is there any good reason you are allowing square brackets? They are chemically incorrect and arguably don't add much to the question.

I've just removed them. :-) Any answers posted before 3AM UTC, September 23, are safe and will not be affected by this change, as per the above edit. @MarchHo

Would it be safe to assume that the numbers are always single digit?

Yes. I just edited to add this detail, also. @RetoKoradi

Challenge would be so much better if you had to output the elements in Atomic Number order :-)

Perhaps the next one will have that element. @corsiKa

I hope so, it will energize the community.

Just a note, the examples still have elements with multiple digit atom counts.

In Perl 5, it seems to me that s/(?|([A-Z][a-z]*)|\(((?0)+)\))(\d)?/$1x($2||1)/ge should work to expand the string (preparatory to parsing it further), but it doesn't. Maybe someone can work with that, though.

CJam, 59 57 bytes
q{:Ci32/")("C#-"[ ] aC~* Ca C+"S/=~}%`La`-S%$e`{~": "@N}/

Try it online in the CJam interpreter.
How it works
q             e# Read all input from STDIN.
{             e# For each character:
  :Ci         e#   Save it in C and cast to integer.
  32/         e#   Divide the code point by 32. This pushes
              e#   2 for uppercase, 3 for lowercase and 1 for non-letters.
  ")("C#      e#   Find the index of C in that string. (-1 if not found.)
  -           e#   Subtract. This pushes 0 for (, 1 for ), 2 for digits,
              e#   3 for uppercase letters and 4 for lowercase letters.

 "[ ] aC~* Ca C+"

 S/           e#   Split it at spaces into ["[" "]" "aC~*" "Ca" "C+"].
 =~           e#   Select and evaluate the corresponding chunk.
              e#     (   : [    : Begin an array.
              e#     )   : ]    : End an array.
              e#     0-9 : aC~* : Wrap the top of the stack into an array
              e#                  and repeat that array eval(C) times.
              e#     A-Z : Ca   : Push "C".
              e#     a-z : C+   : Append C to the string on top of the stack.
}%            e#
`             e# Push a string representation of the resulting array.
              e# For input (Au(CH)2)2, this pushes the string
              e# [[["Au" [["C" "H"] ["C" "H"]]] ["Au" [["C" "H"].["C" "H"]]]]]
La`           e# Push the string [""].
-             e# Remove square brackets and double quotes from the first string.
S%            e# Split the result at runs of spaces.
$e`           e# Sort and perform run-length encoding.
{             e# For each pair [run-length string]:
  ~           e#   Dump both on the stack.
  ": "        e#   Push that string.
  @N          e#   Rotate the run-length on top and push a linefeed.
}/            e#

Python 3, 157 154 bytes
import re
s=re.sub
f=s("[()',]",'',str(eval(s(',?(\d+)',r'*\1,',s('([A-Z][a-z]*)',r'("\1",),',input()))))).split()
for c in set(f):print(c+":",f.count(c))

Try it online!
Only supports input using regular brackets.
Before creating the golfed solution using eval above I created this reference solution, which I found very elegant:
import re, collections

parts = filter(bool, re.split('([A-Z][a-z]*|\(|\))', input()))
stack = [[]]
for part in parts:
    if part == '(':
        stack.append([])
    elif part == ')':
        stack[-2].append(stack.pop())
    elif part.isdigit():
        stack[-1].append(int(part) * stack[-1].pop())
    else:
        stack[-1].append([part])

count = collections.Counter()
while stack:
    if isinstance(stack[-1], list):
        stack.extend(stack.pop())
    else:
        count[stack.pop()] += 1

for e, i in count.items():
    print("{}: {}".format(e, i))

Pyth, 66 65 bytes
VrSc-`v::z"([A-Z][a-z]*)""('\\1',),"",?(\d+)""*\\1,"`(k))8j": "_N

Try it online!
Port of my Python answer. Only supports input using regular brackets.

+1. Three answers in an hour? Nice.

Python 3, 414 bytes
I hope that the order of the result doesn't count.
import re
t=input().replace("[", '(').replace("]", ')')
d={}
p,q="(\([^\(\)]*\))(\d*)","([A-Z][a-z]*)(\d*)"
for i in re.findall(q,t):t = t.replace(i[0]+i[1],i[0]*(1if i[1]==''else int(i[1])))
r=re.findall(p,t)
while len(r)>0:t=t.replace(r[0][0]+r[0][1],r[0][0][1:-1]*(1if r[0][1]==''else int(r[0][1])));r=re.findall(p,t)
for i in re.findall(q[:-5], t):d[i]=d[i]+1if i in d else 1
for i in d:print(i+': '+str(d[i]))

Try it online!

JavaScript ES6, 366 bytes
function f(i){function g(a,b,c){b=b.replace(/[[(]([^[(\])]+?)[\])](\d*)/g,g).replace(/([A-Z][a-z]?)(\d*)/g,function(x,y,z){return y+((z||1)*(c||1))});return(b.search(/[[(]/)<0)?b:g(0,b)}return JSON.stringify(g(0,i).split(/(\d+)/).reduce(function(q,r,s,t){(s%2)&&(q[t[s-1]]=+r+(q[t[s-1]]||0));return q},{})).replace(/["{}]/g,'').replace(/:/g,': ').replace(/,/g,'\n')}

JS Fiddle:
https://jsfiddle.net/32tunzkr/1/
I'm pretty sure this can be shortened, but I need to get back to work. ;-)

I'm pretty sure it can be shortened as well. Since you clame to be using ES6, you could start by using the big-arrow notation to create functions. And the implicit return statement. That should be enough for now.

You also use replace a lot so you can save some bytes by using xyz[R='replace'](...) the first time and abc[R] (...) each subsequent time.

SageMath, 156 148 bytes
import re
i=input()
g=re.sub
var(re.findall("[A-Z][a-z]?",i))
print g("(\d+).(\S+)\D*",r"\2: \1\n",`eval(g("(\d+)",r"*\1",g("([A-Z(])",r"+\1",i)))`)

Try it online here (hopefully link will work, might need an online account)
Note: If trying online, you will need to replace input() with the string (e.g. "(CH3)3COOC(CH3)3")
Explanation
Sage allows you to simplify algebraic expressions, providing they are in the right format (see 'symbolic manipulation' of this link). The regexes inside the eval() basically serve to get the input string into the right format, for example something like:
+(+C+H*3)*3+C+O+O+C+(+C+H*3)*3

eval() will then simplify this to: 8*C + 18*H + 2*O, and then it's just a matter of formatting the output with another regex substitution.

Javascript (ES6), 286 284
Not that much shorter than the other ES6 one but I gave it my best. Note: this will error out if you give it an empty string or most invalid inputs. Also expects all groups to have a count of more than 1 (ie, no CO[OH]). If this breaks any challenge rules, let me know.
a=>(b=[],c={},a.replace(/([A-Z][a-z]*)(?![0-9a-z])/g, "$11").match(/[A-Z][a-z]*|[0-9]+|[\[\(]/g).reverse().map(d=>(d*1==d&&b.push(d*1),d.match(/\(|\[/)&&b.pop(),d.match(/[A-Z]/)&&eval('e=b.reduce((f,g)=>f*g,1),c[d]=c[d]?c[d]+e:e,b.pop()'))),eval('g="";for(x in c)g+=x+`: ${c[x]}\n`'))

Uses a stack-based approach. First, it preprocesses the string to add 1 to any element without a number, ie Co3(Fe(CN)6)2 becomes Co3(Fe1(C1N1)6)2. Then it loops through in reverse order and accumulates element counts.
a=>(
  // b: stack, c: accumulator
  b=[], c={},

  // adds the 1 to every element that doesn't have a count
  a.replace(/([A-Z][a-z]*)(?![0-9a-z])/g, "$11")

    // gathers a list of all the elements, counts, and grouping chars
    .match(/[A-Z][a-z]*|[0-9]+|[\[\(]/g)

    // loops in reverse order
    .reverse().map(d=>(

       // d*1 is shorthand here for parseInt(d)
       // d*1==d: true only if d is a number
       // if it's a number, add it to the stack
       d * 1 == d && b.push(d * 1),

       // if there's an opening grouping character, pop the last item
       // the item being popped is that group's count which isn't needed anymore
       d.match(/\(|\[/) && b.pop(),

       // if it's an element, update the accumulator
       d.match(/[A-Z]/) && eval('

         // multiplies out the current stack
         e = b.reduce((f, g)=> f * g, 1),

         // if the element exists, add to it, otherwise create an index for it
         c[d] = c[d] ? c[d] + e : e,

         // pops this element's count to get ready for the next element
         b.pop()
       ')
  )),

  // turns the accumulator into an output string and returns the string
  eval('
    g="";

    // loops through each item of the accumulator and adds it to the string
    // for loops in eval always return the last statement in the for loop
    // which in this case evaluates to g
    for(x in c)
      g+=x+`: ${c[x]}\n`
  ')
)

Fiddle

Perl, 177 172 bytes
171 bytes code + 1 byte command line parameter
Ok, so I may have got a little carried away with regex on this one...
s/(?>[A-Z][a-z]?)(?!\d)/$&1/g;while(s/\(([A-Z][a-z]?)(\d+)(?=\w*\W(\d+))/$2.($3*$4).$1/e||s/([A-Z][a-z]?)(\d*)(\w*)\1(\d*)/$1.($2+$4).$3/e||s/\(\)\d+//g){};s/\d+/: $&\n/g

Usage example:
echo "(CH3)3COOC(CH3)3" | perl -p entry.pl

Mathematica, 152 bytes
f=TableForm@Cases[PowerExpand@Log@ToExpression@StringReplace[#,{a:(_?UpperCaseQ~~___?LowerCaseQ):>"\""<>a<>"\"",b__?DigitQ:>"^"<>b}],a_. Log[b_]:>{b,a}]&

The above defines a function f which takes a string as input. The function takes the string and wraps each element name into quotes and adds an infix exponentiation operator before each number, then interprets the string as an expression:
"YBa2Cu3O7" -> ""Y""Ba"^2"Cu"^3"O"^7" -> "Y" "Ba"^2 "Cu"^3 "O"^7

Then it takes the logarithm of that and expands it out (mathematica doesn't care, what to take the logarithm of :)):
Log["Y" "Ba"^2 "Cu"^3 "O"^7] -> Log["Y"] + 2 Log["Ba"] + 3 Log["Cu"] + 7 Log["O"]

and then it finds all occurrences of multiplication of a Log by a number and parses it into the form of {log-argument, number} and outputs those in a table. Some examples:
f@"K4(ON(SO3)2)2"
K   4
N   2
O   14
S   4

f@"(CH3)3COOC(CH3)3"
C   8
H   18
O   2

f@"Co3(Fe(CN)6)2"
C   12
Co  3
Fe  2
N   12

Java, 827 bytes
import java.util.*;class C{String[]x=new String[10];public static void main(String[]a){new C(a[0]);}C(String c){I p=new I();int[]d=d(c,p);for(int i=0;i<10;i++)if(x[i]!=null)System.out.println(x[i]+": "+d[i]);}int[]d(String c,I p){int[]f;int i,j;Vector<int[]>s=new Vector();while(p.v<c.length()){char q=c.charAt(p.v);if(q=='(')s.add(d(c,p.i()));if(q==')')break;if(q>='A'&&q<='Z'){f=new int[10];char[]d=new char[]{c.charAt(p.v),0};i=1;if(c.length()-1>p.v){d[1]=c.charAt(p.v+1);if(d[1]>='a'&&d[1]<='z'){i++;p.i();}}String h=new String(d,0,i);i=0;for(String k:x){if(k==null){x[i]=h;break;}if(k.equals(h))break;i++;}f[i]++;s.add(f);}if(q>='0'&&q<='9'){j=c.charAt(p.v)-'0';f=s.get(s.size()-1);for(i=0;i<10;)f[i++]*=j;}p.i();}f=new int[10];for(int[]w:s){j=0;for(int k:w)f[j++]+=k;}return f;}class I{int v=0;I i(){v++;return this;}}}

Git repository w/ ungolfed source (not perfect parity, ungolfed supports multi-character numbers).
Been a while, figured I'd give Java some representation. Definitely not going to win any awards :).

ES6, 198 bytes
f=s=>(t=s.replace(/(([A-Z][a-z]?)|\(([A-Za-z]+)\))(\d+)/,(a,b,x,y,z)=>(x||y).repeat(z)))!=s?f(t):(m=new Map,s.match(/[A-Z][a-z]?/g).map(x=>m.set(x,-~m.get(x))),[...m].map(([x,y])=>x+": "+y).join`\n`)

Where \n is a literal newline character.
Ungolfed:
function f(str) {
    // replace all multiple elements with individual copies
    // then replace all groups with copies working outwards
    while (/([A-Z][a-z]?)(\d+)/.test(str) || /\(([A-Za-z]+)\)(\d+)/.test(str)) {
        str = RegExp.leftContext + RegExp.$1.repeat(RegExp.$2) + RegExp.rightContext;
    }
    // count the number of each element in the expansion
    map = new Map;
    str.match(/[A-Z][a-z]?/g).forEach(function(x) {
        if (!map.has(x)) map.set(x, 1);
        else map.set(x, map.get(x) + 1);
    }
    // convert to string
    res = "";
    map.forEach(function(value, key) {
        res += key + ": " + value + "\n";
    }
    return res;
}

Pip -l, 85 77 62 bytes
Takes the formula as a command-line argument, and uses the -l flag for proper output formatting.
_.": ".(_N Y(VaRl:XU+KXL`"&"`RXI`X&`R`[\d"][("]`{aJ'.}l))MUQy

Try it online!
The main trick is to transform the formula via regex replacements into a Pip expression. This, when eval'd, will do the repetition and resolve parentheses for us. We then post-process a bit to get the atom counts and format everything correctly.
Ungolfed, with comments:
                        a is command-line arg (implicit)
l:`[A-Z][a-z]*`         Regex matching element symbols
aR: l `"&"`             Replace each symbol in a with symbol wrapped in quotes
aR: XI `X&`             Add X before each number (XI is a regex matching integers)
aR: `[\d"][("]` {aJ'.}  Insert . between a digit or " and a ( or "
Y (Va)@l                Eval result, findall matches of l, and yank that list into y
_.": ".(_Ny) M UQy      Map function to y uniquified:
                        Each element, concatenated with ": ", concatenated with
                        the count of that element in y
                        Print that list, one element per line (implicit, -l flag)

Here's how the input Co3(Fe(CN)6)2 is transformed:
Co3(Fe(CN)6)2
"Co"3("Fe"("C""N")6)2
"Co"X3("Fe"("C""N")X6)X2
"Co"X3.("Fe".("C"."N")X6)X2
CoCoCoFeCNCNCNCNCNCNFeCNCNCNCNCNCN

Then:
["Co" "Co" "Co" "Fe" "C" "N" "C" "N" "C" "N" "C" "N" "C" "N" "C" "N" "Fe" "C" "N" "C" "N" "C" "N" "C" "N" "C" "N" "C" "N"]
["Co" "Fe" "C" "N"]
[3 2 12 12]
["Co: 3" "Fe: 2" "C: 12" "N: 12"]

Perl 5 -MList::Util=pairmap -n, 94 bytes
s/\(([^()]+?)\)(\d)/$1x$2/e&&redo;s/([A-Z][a-z]*)(\d?)/$k{$1}+=$2||1/ge;pairmap{say"$a: $b"}%k

Try it online!

JavaScript (Node.js), 133 bytes
x=>x.replace(/[A-Z][a-z]*|\d+|./g,c=>d=[c<'/'?c<')'?'}':'{':+c?`for(_ in"${Array(-~c)}")`:`o.${c}=-~o.${c};`]+d,d='',o={})+eval(d)&&o

Try it online!
Would remain shorter than the existing ones using same old ECMAscript

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


text:
Find the Chemistry of a name
We all have knowledge of the periodic table, since our days in school.
Something most of us have often tried to do is to spell out your name using elements of the table.
Your challenge is to do exactly this.
You will be given a string to STDIN or equivalent, and you will need to output the formula corresponding to the name, in the form <formula> : <Elements names spelled out>
In case nothing corresponds print: :(
Use this list for element names: List of elements
This is code-golf, so the shortest answer wins.
Standard loopholes rules apply
Examples
Input: Smith
Output: Sm I Th : Samarium Iodine Thorium
Input: Oscar Kou
Output: Os C Ar K O U : Osmium Carbon Argon Potassium Oxygen Uranium
Input: Giacomo Fenzi
Output::(

Clarifications
There may be occurrences of the input being divisible in two or more ways, in this case choose the output with the least number of elements in. If even this case brings to ambiguity you are free to choose which output to print.
You may expect an input consisting of only letters and spaces, no numbers nor other characters used. Spaces in the input should be ignored, and do not change or "split" it.
Please format your answer in the following way:
Language, Number of Bytes, Number of Bytes excluding the bytes to store the elements
EDIT
I think this question is fundamentally different from this one, since it asks to find the elements that compose a word and additionally requires to write their full names out, instead of finding the set of words spellable with the periodic table

only letters, and, well, spaces. I guess.

What should output be for A L?

@minxomat yes of course :)

Geobits --> :(

Could you provide a periodic table / list of elements and names for everyone to use?

@Loovjo of course, I'll do it

@ThomasKwa it will output Al : Alluminium

@WizardOfMenlo Not "Aluminium" or "Aluminum"? See here.

@mbomb007 I'll put a list with the correct  spellings, the one above is just what my phone said :)

@WizardOfMenlo It shouldn't have 2 ls. That's an incorrect spelling. Use a dictionary, not your phone.

Does the periodic table data need to be included in the code count?

@alexanderbird I think it would be better, it would be great if you could add the score with and without the data close to your anwer

Which one determines the winner?

@ThomasKwa I think the total one