text:
Words with Blocks
Given a dictionary of 4-letter words that have no repeated characters (from this list of words), you must choose ONE of those words, and output that specific word using the following dictionary of block letters:
 .----------------.  .----------------.  .----------------.  .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| |      __      | || |   ______     | || |     ______   | || |  ________    | |
| |     /  \     | || |  |_   _ \    | || |   .' ___  |  | || | |_   ___ '.  | |
| |    / /\ \    | || |    | |_) |   | || |  / .'   \_|  | || |   | |   '. \ | |
| |   / ____ \   | || |    |  __'.   | || |  | |         | || |   | |    | | | |
| | _/ /    \ \_ | || |   _| |__) |  | || |  \ '.___.'\  | || |  _| |___.' / | |
| ||____|  |____|| || |  |_______/   | || |   '._____.'  | || | |________.'  | |
| |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------'
 .----------------.  .----------------.  .----------------.  .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| |  _________   | || |  _________   | || |    ______    | || |  ____  ____  | |
| | |_   ___  |  | || | |_   ___  |  | || |  .' ___  |   | || | |_   ||   _| | |
| |   | |_  \_|  | || |   | |_  \_|  | || | / .'   \_|   | || |   | |__| |   | |
| |   |  _|  _   | || |   |  _|      | || | | |    ____  | || |   |  __  |   | |
| |  _| |___/ |  | || |  _| |_       | || | \ '.___]  _| | || |  _| |  | |_  | |
| | |_________|  | || | |_____|      | || |  '._____.'   | || | |____||____| | |
| |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------'
 .----------------.  .----------------.  .----------------.  .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| |     _____    | || |     _____    | || |  ___  ____   | || |   _____      | |
| |    |_   _|   | || |    |_   _|   | || | |_  ||_  _|  | || |  |_   _|     | |
| |      | |     | || |      | |     | || |   | |_/ /    | || |    | |       | |
| |      | |     | || |   _  | |     | || |   |  __'.    | || |    | |   _   | |
| |     _| |_    | || |  | |_' |     | || |  _| |  \ \_  | || |   _| |__/ |  | |
| |    |_____|   | || |  '.___.'     | || | |____||____| | || |  |________|  | |
| |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------'
 .----------------.  .-----------------. .----------------.  .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| | ____    ____ | || | ____  _____  | || |     ____     | || |   ______     | |
| ||_   \  /   _|| || ||_   \|_   _| | || |   .'    '.   | || |  |_   __ \   | |
| |  |   \/   |  | || |  |   \ | |   | || |  /  .--.  \  | || |    | |__) |  | |
| |  | |\  /| |  | || |  | |\ \| |   | || |  | |    | |  | || |    |  ___/   | |
| | _| |_\/_| |_ | || | _| |_\   |_  | || |  \  '--'  /  | || |   _| |_      | |
| ||_____||_____|| || ||_____|\____| | || |   '.____.'   | || |  |_____|     | |
| |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------'
 .----------------.  .----------------.  .----------------.  .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| |    ___       | || |  _______     | || |    _______   | || |  _________   | |
| |  .'   '.     | || | |_   __ \    | || |   /  ___  |  | || | |  _   _  |  | |
| | /  .-.  \    | || |   | |__) |   | || |  |  (__ \_|  | || | |_/ | | \_|  | |
| | | |   | |    | || |   |  __ /    | || |   '.___'-.   | || |     | |      | |
| | \  '-'  \_   | || |  _| |  \ \_  | || |  |'\____) |  | || |    _| |_     | |
| |  '.___.\__|  | || | |____| |___| | || |  |_______.'  | || |   |_____|    | |
| |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------'
 .----------------.  .----------------.  .----------------.  .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| | _____  _____ | || | ____   ____  | || | _____  _____ | || |  ____  ____  | |
| ||_   _||_   _|| || ||_  _| |_  _| | || ||_   _||_   _|| || | |_  _||_  _| | |
| |  | |    | |  | || |  \ \   / /   | || |  | | /\ | |  | || |   \ \  / /   | |
| |  | '    ' |  | || |   \ \ / /    | || |  | |/  \| |  | || |    > '' <    | |
| |   \ '--' /   | || |    \ ' /     | || |  |   /\   |  | || |  _/ /''\ \_  | |
| |    '.__.'    | || |     \_/      | || |  |__/  \__|  | || | |____||____| | |
| |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------'
 .----------------.  .----------------.
| .--------------. || .--------------. |
| |  ____  ____  | || |   ________   | |
| | |_  _||_  _| | || |  |  __   _|  | |
| |   \ \  / /   | || |  |_/  / /    | |
| |    \ \/ /    | || |     .'.' _   | |
| |    _|  |_    | || |   _/ /__/ |  | |
| |   |______|   | || |  |________|  | |
| |              | || |              | |
| '--------------' || '--------------' |
 '----------------'  '----------------'

Depending on how old you are, you may have just been given an injection of nostalgia from these block-based letters. Then again, past a certain point, you may have the nostalgia from watching your kids spell these block-based words out on their own. First originating in 1693, alphabet blocks were a pretty common education piece of the nuclear family and beyond. We're going to recreate this nostalgia by spelling a word from this list of words.
In other words, this challenge is to pick four letters from the keyspace definition and render them "stacked" in an order specified by the dictionary. You'll notice the dictionary omits 4-letter words like moon as they repeat letters, and are basically cheat-words.
Here is the block structure itself with no character inside:
 .----------------.
| .--------------. | # Tops are periods.
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| '--------------' | # Bottoms are apostrophe's.
 '----------------'

Rules

Characters inside the blocks only use: |/\_'.]-><.
Numbers don't exist, nor do symbols; only the letters in the word list.
This is a kolmogorov-complexity problem after you've chosen your word, you must output each block exactly as shown.
You may output them in any format you want, vertical, horizontal, stacked in a square; however, it must read top-to-bottom, left-to-right. Also, each block must be displayed without being altered, in a coherent format. This is to give more freedom to save bytes and allow a diverse output structure, much like how it would be when playing with blocks.
The main competitive element of this challenge is both compression optimization and, like my other problem, also factors in your ability to problem solve given the leg-room of seemingly "aesthetic" choice.

Examples
 .----------------.  .----------------.  .----------------.  .----------------.
| .--------------. || .--------------. || .--------------. || .--------------. |
| |  _________   | || |  ____  ____  | || |   ______     | || |  _________   | |
| | |  _   _  |  | || | |_  _||_  _| | || |  |_   __ \   | || | |_   ___  |  | |
| | |_/ | | \_|  | || |   \ \  / /   | || |    | |__) |  | || |   | |_  \_|  | |
| |     | |      | || |    \ \/ /    | || |    |  ___/   | || |   |  _|  _   | |
| |    _| |_     | || |    _|  |_    | || |   _| |_      | || |  _| |___/ |  | |
| |   |_____|    | || |   |______|   | || |  |_____|     | || | |_________|  | |
| |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------'

Is the same validity as:
 .----------------.
| .--------------. |
| |  _________   | |
| | |  _   _  |  | |
| | |_/ | | \_|  | |
| |     | |      | |
| |    _| |_     | |
| |   |_____|    | |
| |              | |
| '--------------' |
 '----------------'
 .----------------.
| .--------------. |
| |  ____  ____  | |
| | |_  _||_  _| | |
| |   \ \  / /   | |
| |    \ \/ /    | |
| |    _|  |_    | |
| |   |______|   | |
| |              | |
| '--------------' |
 '----------------'
 .----------------.
| .--------------. |
| |   ______     | |
| |  |_   __ \   | |
| |    | |__) |  | |
| |    |  ___/   | |
| |   _| |_      | |
| |  |_____|     | |
| |              | |
| '--------------' |
 '----------------'
 .----------------.
| .--------------. |
| |  _________   | |
| | |_   ___  |  | |
| |   | |_  \_|  | |
| |   |  _|  _   | |
| |  _| |___/ |  | |
| | |_________|  | |
| |              | |
| '--------------' |
 '----------------'

Which is just as valid as:
                     .----------------.
                    | .--------------. |
                    | |  _________   | |
                    | | |  _   _  |  | |
                    | | |_/ | | \_|  | |
                    | |     | |      | |
                    | |    _| |_     | |
                    | |   |_____|    | |
                    | |              | |
                    | '--------------' |
                     '----------------'
 .----------------.  .----------------.  .----------------.
| .--------------. || .--------------. || .--------------. |
| |  ____  ____  | || |   ______     | || |  _________   | |
| | |_  _||_  _| | || |  |_   __ \   | || | |_   ___  |  | |
| |   \ \  / /   | || |    | |__) |  | || |   | |_  \_|  | |
| |    \ \/ /    | || |    |  ___/   | || |   |  _|  _   | |
| |    _|  |_    | || |   _| |_      | || |  _| |___/ |  | |
| |   |______|   | || |  |_____|     | || | |_________|  | |
| |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'

This also works:
 .----------------.  .----------------.
| .--------------. || .--------------. |
| |  _________   | || |  ____  ____  | |
| | |  _   _  |  | || | |_  _||_  _| | |
| | |_/ | | \_|  | || |   \ \  / /   | |
| |     | |      | || |    \ \/ /    | |
| |    _| |_     | || |    _|  |_    | |
| |   |_____|    | || |   |______|   | |
| |              | || |              | |
| '--------------' || '--------------' |
 '----------------'  '----------------'
 .----------------.  .----------------.
| .--------------. || .--------------. |
| |   ______     | || |  _________   | |
| |  |_   __ \   | || | |_   ___  |  | |
| |    | |__) |  | || |   | |_  \_|  | |
| |    |  ___/   | || |   |  _|  _   | |
| |   _| |_      | || |  _| |___/ |  | |
| |  |_____|     | || | |_________|  | |
| |              | || |              | |
| '--------------' || '--------------' |
 '----------------'  '----------------'

Even stuff that seems like it would cost bytes for you to do:
    .----------------.  .----------------.
   | .--------------. || .--------------. |
   | |  _________   | || |  ____  ____  | |
   | | |  _   _  |  | || | |_  _||_  _| | |
   | | |_/ | | \_|  | || |   \ \  / /   | |
   | |     | |      | || |    \ \/ /    | |
   | |    _| |_     | || |    _|  |_    | |
   | |   |_____|    | || |   |______|   | |
   | |              | || |              | |
   | '--------------' || '--------------' |
    '----------------'  '----------------'
           .----------------.  .----------------.
          | .--------------. || .--------------. |
          | |   ______     | || |  _________   | |
          | |  |_   __ \   | || | |_   ___  |  | |
          | |    | |__) |  | || |   | |_  \_|  | |
          | |    |  ___/   | || |   |  _|  _   | |
          | |   _| |_      | || |  _| |___/ |  | |
          | |  |_____|     | || | |_________|  | |
          | |              | || |              | |
          | '--------------' || '--------------' |
           '----------------'  '----------------'

However you can stack the blocks to save yourself bytes is a winner in my book.
This is code-golf, lowest byte-count wins.

I'm only 17 and those give me nostalgia.

Nice challenge! +1

I'm going to guess that the the most popular word will either be hide or waxy.

@Neil What is your "guess" based on?

@EriktheOutgolfer It's based on the most symmetrical-looking letters.

@Neil I don't think any of the letters is symmetrical, although they seem like that (e.g. is ()() a palindrome?).

That's why I said symmetrical looking - but I bet there are some esolangs out that that can reflect ( into ) etc.

I have added compress methods in my approach. Are these methods allowed?

@Neil charcoal can do this :P

@carusocomputing So it can!

The full list of words that charcoal can mirror seems to be: ahoy hoax mayo waxy wham whoa whom. It just remains to determine which letters are easiest to draw.

@carusocomputing AHOY there!

Is it mandatory to use the full character set to achieve the output, or could a single character be used to achieve the output?

Charcoal, 180 164 162 159 158 155 bytes
→⁸↘.↓⁹← '←⁸↗→⁶↗'↑⁷← .←⁶↘Ｆ³Ｃ⁰¦¹¹↓↓↗²____↓←|_↓↓³↗↘_←|_____↑¹↗²↓↓²↖↙_Ｍ⁶↓↘_↘⁴↑↘_←|____↑¹→↖\_↓\_Ｍχ↓↗²← _↑¹ ____↓←|↙_↙²|_↓←|___↘Ｍ⁵↓_↘_→'↘.↓\|↙¹←'.__↗→¹↗'↖|←.-‖Ｍ←

Try it online! Edit: Saved 16 18 bytes by manually drawing the letters WAY; unfortunately X turns out to be too hard to draw, so it's still printed using a string literal. Saved a further 3 bytes by switching from WAXY to AHOY. Saved another byte by switching to MAYO because I can use the predefined χ variable for 10. Saved a further 3 bytes by repeating the copy of the border in a loop. Explanation:
→⁸↘.↓⁹← '←⁸↗    Draw the outer right half of a block
→⁶↗'↑⁷← .←⁶↘    Draw the inner right half of a block
Ｆ³Ｃ⁰¦¹¹         Make three copies of the right half of the block
↓↓              Move into position and draw an M right half
↗²____↓←|_↓↓³↗↘_←|_____↑¹↗²↓↓²↖↙_
Ｍ⁶↓             Move into position and draw an A right half
↘_↘⁴↑↘_←|____↑¹→↖\_↓\_
Ｍχ↓             Move into position and draw a Y right half
↗²← _↑¹ ____↓←|↙_↙²|_↓←|___↘
Ｍ⁵↓             Move into position and draw an O right half
_↘_→'↘.↓\|↙¹←'.__↗→¹↗'↖|←.-
‖Ｍ←             Reflect to the left

Full list of letter right halves:
A   ↘_↘⁴↑↘_←|____↑¹→↖\_↓\_              (22 bytes)
H   _↑¹←↑¹ ____↓←|_↓↓³↗↘_←|____↑¹→↑¹←↓_ (35 bytes)
M   ↗²____↓←|_↓↓³↗↘_←|_____↑¹↗²↓↓²↖↙_   (33 bytes)
O   _↘_→'↘.↓\|↙¹←'.__↗→¹↗'↖|←.-↘        (28 bytes)
W   ↘²↑↑²← _↑¹ _____↓←|_↓↓⁴↖←__↖²↘      (30 bytes)
X    ____¶|_  _|¶ / /¶' <¶'\ \_¶|____|¶ (35 bytes)
Y   ↗²← _↑¹ ____↓←|↙_↙²|_↓←|___↘        (28 bytes)

If O, W, X or Y is the last letter then the last byte can be removed. On the other hand, M, W and Y cost 2 bytes as a first letter or a byte as the letter after O; H costs a byte as a first letter. With the above byte counts, the following words are possible:
MAYO 155 bytes (43+33+22+28+28+2-1)
AHOY 156 bytes (43+22+35+28+28+1-1)
WAXY 159 bytes (43+30+22+35+28+2-1)
WHOA 160 bytes (43+30+35+28+22+2)
HOAX 163 bytes (43+35+28+22+35+1-1)
WHAM 165 bytes (43+30+35+22+33+2)
WHOM 171 bytes (43+30+35+28+33+2)

I like how you calculated the alternatives too, seems like the Jelly submission may be able to use AHOY for less too?

@carusocomputing In order to save bytes he can't use letters that need both sorts of slashes on the same side, and WHAM is the only word that fits.

It's actually the .s and 's of the O that are the real killers (I'd be compressing as a base 6 number instead of a base 4 one).

@JonathanAllan Indeed, but the only other mirrorable letter, X, has its own share of problems too.

@Neil was this your first charcoal answer?

@carusocomputing According to https://codegolf.stackexchange.com/search?tab=newest&q=user:17602+Charcoal it's my third Charcoal answer.

PHP, 362 Bytes
MILK
$a="--------------";$b=977775;echo strtr("2222
1111
5 6886 5976_885576_7759___8675
507\8/7_|59807_|75907_|7855 08|08_|85
9|7\/7|85577975989875575_/ /885
95\8/955779759857_7557|8__'.885
5 _5_\/_5_ 597_5_88557_5__/ |859_9\ \_85
506|06|59806|759|66|855 |6||6| 5
$b$b$b$b
3333
4444",
["|_","| .$a. |"," .-$a-. ","| '$a' |"," '-$a-' ","| |",____,"   ","  ","| |  "]);

Try it online!
PHP, 258 Bytes Only compressed
echo gzinflate(base64_decode("pZI5DsUgDET7nMJdqsCFkHyROfxnHJaB6iu4iOFhjxfF0rNZMjtgF3aaDCesCsK8mlULDwbC+j0eBhtksgAN4xUEz8UsMwNTMLhDkicZjCgUiJugRX7JEaUdWj9Ikf40GUVzdKOCYIf4V9BXwTrxnVTQWaTkcMsO34l0hyS1Hyns8S1WXHZIG052GGDZYTPIDkcu5shqOvIHVgXv9V+6GfidXTsjPWE/"));

Try it online!
PHP, 323 Bytes Code above compress with use of eval
eval(gzinflate(base64_decode("VVBdawQhDHz3VwQRbOF2135EI8v9klrCXincW+F6j/nxneyWQkdxwswYg2k7x+kf4pou594AXj8/rl/0fb/dbw/xGQhPQGCqIpW4t6oizCCEu6pKbRy4tCFLU+MuBQRrJySpiBVREw7d2lia+fXWEZEuDTXrQou4z2jS/1xu6raJap7dZ1LWseDwQUD7JGA0QNeufdBQD5Zq2D5M9VmsVn+VrBo2cUiXY4UXILwC8RTeomk8RaM5bTMZSpqntE0z7WpOWz7U7Go+VAj4BIVKLtCvCn5/XH8A")));

Try it online!

I mean, I don't see why they wouldn't be valid. They're boring though. If you choose to use the shorter compression answers to save bytes please keep the one you worked out as well :).

@carusocomputing I would say if they are not valid the challenge is more interesting. Otherwise it could end in only compressed solutions

I don't want to limit too much, else languages that use non-built-in compression for ASCII challenges won't be able to compete.

Jelly, 119 114 bytes
WHAM
“ƭHGE94=ẠĊỴI>ạȧⱮṅƇṾ'Ñɦȥ⁴7?6ụ\ĖḂẆṾƇṗyZḣ&c%~Œ’ṃ“ |\_”s7;€“| |”µṚ“\/”y;µ€s6U4¦
“ŒUỴ2,Ɠ’ṃ“|'-. ”s4µṪẋ7ṭµ€m€0s3ṚjÐ€¢Y€Y

Try it online!
How?
The general idea is to choose letters which have left-right symmetry with minimal character translation so as to (a) reduce the base in which the data may be encoded and (b) keep the "reflection" function small.
The letter H has left-right symmetry with no need for translation. The letters W and A also have left-right symmetry if the /s on the left become \s on the right. Unfortunately there are not four such letters (with the same sides having the same slopes of slashes).
Letters such as O introduce more characters, which increases the base needed for encryption making for a far larger number and hence more bytes.
M, however, only introduces the other slash - if the half rows for the M are stored in reverse and with the wrong slashes, the base is kept at four and a post-decryption, post-reflection reversal of just these rows puts everything right again (this is the U4¦ in Link 1). This also means the character translation only needs to cater for \ becoming / and not the other way around too (i.e. Ṛ“\/”y; rather than Ṛ“\/“/\”y;).
“...’ṃ“ |\_”s7;€“| |”µṚ“\/”y;µ€s6U4¦ - Link 1: middle rows of blocks: no arguments
“...’                                - base 250 number
     ṃ“ |\_”                         - convert to base 4 with digits [0-3]="_ |\"
            s7                       - split into sevens
                “| |”                - literal "| |"
              ;€                     - concatenate €ach
                     µ               - monadic chain separation (call that rhs)
                             µ€      - for each r in rhs:
                      Ṛ              -     reverse r
                       “\/”y         -     convert any '\'s to '/'s
                            ;        -     concatenate with r
                               s6    - split into sixes
                                   ¦ - apply to indexes...
                                  4  -   four (the M)
                                 U   -   upend

“ŒUỴ2,Ɠ’ṃ“|'-. ”s4µṪẋ7ṭµ€m€0s3ṚjÐ€¢Y€Y - Main link: no arguments
“ŒUỴ2,Ɠ’                               - base 250 number
        ṃ“ -|.'”                       - convert to base 5 with digits [0-4]="' -|."
                s4                     - split into fours
                  µ                    - monadic chain separation (call that lhs)
                       µ€              - for each l in lhs:
                   Ṫ                   -   tail l
                    ẋ7                 -   repeat (the tail) seven times
                      ṭ                -   tack to l
                         m€0           - reflect €ach
                            s3         - split into threes
                              Ṛ        - reverse
                                  ¢    - call last link (1) as a nilad
                               jÐ€     - join mapped over right
                                   Y€  - join each with newlines
                                     Y - join with newlines
                                       - implicit print

Surely M's /s are the same way around as Ys?

Yep I must have missed that when looking for words :/

Javascript 433 416 characters
Yeah, it is not very impressive. But I put this much work in and I don't see any easy way to get a lot better :)
_=>{r=(s,x)=>s.repeat(x)
Z='| |'
q=(s,x)=>Z+r(_=' ',x)+s+r(_,14-s.length-x)+Z
h=r('-',14)
Y=(a,o)=>` .-${h}-. \n| .${h}. |
`+a.map((s,i)=>q(s,[2,1,3,3,2,1][i]+o)).join(N='\n')+N+q(r(_,14))+`
| '${h}' |
 '-${h}-'
`
return Y([i=r(U='_',5),j='|_   _|',Z,Z+'    _',l='_| |___/ |',m=`|${i}____|`],1)+Y([i,j,Z,Z,I=U+Z+U,J=`|${i}|`],3)+Y([e=r(U,9),f='|_   ___  |',g=Z+'_  \\_|','|  _|',I,J],0)+Y([e,f,g,'|  _|  _',l,m],0)}

Not sure my letters are perfectly well formed:
 .----------------.
| .--------------. |
| |   _____      | |
| |  |_   _|     | |
| |    | |       | |
| |    | |    _  | |
| |   _| |___/ | | |
| |  |_________| | |
| |              | |
| '--------------' |
 '----------------'
 .----------------.
| .--------------. |
| |     _____    | |
| |    |_   _|   | |
| |      | |     | |
| |      | |     | |
| |     _| |_    | |
| |    |_____|   | |
| |              | |
| '--------------' |
 '----------------'
 .----------------.
| .--------------. |
| |  _________   | |
| | |_   ___  |  | |
| |   | |_  \_|  | |
| |   |  _|      | |
| |  _| |_       | |
| | |_____|      | |
| |              | |
| '--------------' |
 '----------------'
 .----------------.
| .--------------. |
| |  _________   | |
| | |_   ___  |  | |
| |   | |_  \_|  | |
| |   |  _|  _   | |
| |  _| |___/ |  | |
| | |_________|  | |
| |              | |
| '--------------' |
 '----------------'

The result is saved to the a variable.

Bubblegum, 119 bytes
00000000: d5d2 0106 0341 1483 6100 e614 3fb0 60a6  .....A..a...?.`.
00000010: 172a b948 0e5f 08d2 a754 a9d2 80f5 2df8  .*.H._...T....-.
00000020: bde1 ecb1 b33c f1e0 650c 4892 00c0 412c  .....<..e.H...A,
00000030: 406e cc27 bc46 3522 63e9 860b adac b017  @n.'.F5"c.......
00000040: bcf6 d32e bcda a2eb b3c8 ce34 c1ce 2c4c  ...........4..,L
00000050: d17b 4ce6 40a7 f1f7 91ca ea14 2994 e853  .{L.@.......)..S
00000060: 901f 770d ccc9 0b53 d858 85ff 1b29 66e4  ..w....S.X...)f.
00000070: 78ae d637 9feb 03                        x..7...

Try it online!
LIFE. Here is a list of all letters in a more readable format I used for trying out every single word.

Great effort. Fortunately it still didn't beat Jelly. (???) (only 5 bytes)

Wellp, only answer in 5 days is also 5 bytes from winning. +300 haha.

Deadfish~, 3977 bytes
{iii}iic{i}iiiicd{c}ccccccic{d}ddddcc{i}iiiicd{c}ccccccic{d}ddddcc{i}iiiicd{c}ccccccic{d}ddddcc{i}iiiicd{c}ccccccic{d}ddddc{dd}ddc{{i}}{i}iiiic{{d}i}ddc{i}iiiicd{c}ccccic{d}ddddc{{i}d}iicc{{d}i}ddc{i}iiiicd{c}ccccic{d}ddddc{{i}d}iicc{{d}i}ddc{i}iiiicd{c}ccccic{d}ddddc{{i}d}iicc{{d}i}ddc{i}iiiicd{c}ccccic{d}ddddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{{i}d}iic{{d}i}ddcc{iiiiii}iiiccccccccc{dddddd}dddccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcc{iiiiii}iiicccc{dddddd}dddcc{iiiiii}iiicccc{dddddd}dddcc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddccc{iiiiii}iiicccccc{dddddd}dddccccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcc{iiiiii}iiiccccccccc{dddddd}dddccc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}i}ddcc{iiiiii}iiic{dddddd}dddccc{iiiiii}iiic{dddddd}dddcc{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddc{{i}d}iic{ddd}ic{dddddd}dddcc{iiiiii}iiic{iii}dcc{ddd}ic{dddddd}dddcc{iiiiii}iiic{iii}dc{{d}i}ddc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcc{{i}d}iic{ddd}ic{dddddd}dddccc{iiiiii}iiicc{dddddd}dddc{iiiiii}c{dddddd}ccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddc{{i}d}iic{ddd}ic{dddddd}dddccc{iiiiii}iiiccc{dddddd}dddcc{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{{i}d}iic{{d}i}ddc{{i}d}iic{ddd}ic{ddddd}iic{d}dddddc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}i}ddc{iiiiii}ciiic{iii}dc{{d}i}ddcc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddccc{iiiiii}c{dddddd}c{iiiiii}c{dddddd}cc{i}iiiiic{d}dddddc{i}iiiiic{d}dddddccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddc{{i}d}iic{ddd}icc{ddddd}ddddc{d}ic{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}i}ddc{{i}d}iic{ddd}ic{dddddd}dddcc{iiiiii}ciiic{iii}dc{{d}i}ddcc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{{i}d}iic{{d}i}ddccccc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}i}ddcccccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcccc{iiiiii}c{dddddd}c{iiiiii}c{dddd}dddddc{d}dddddc{i}iiiiic{d}dddddcccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcccc{{i}d}iic{{d}i}ddcc{iiiiii}iiiccc{ddddd}iic{d}dddddccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddccc{{i}d}iic{{d}i}ddcc{iiiiii}iiic{iii}dc{{d}i}ddcc{iiiiii}iiic{dddddd}dddccc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{{i}d}iic{{d}i}ddcccc{iiiiii}iiic{iii}dc{{d}i}ddc{{i}d}iic{ddd}ic{dddddd}dddccccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcccc{iiiiii}iiic{iii}dc{{d}i}ddcc{{i}d}iic{ddd}ic{dddddd}dddcccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddccc{iiiiii}iiic{iii}dc{{d}i}ddc{{i}d}iic{ddd}ic{dddddd}dddcccccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcc{iiiiii}iiic{iii}dc{{d}i}ddc{{i}d}iic{ddd}iccc{ddddd}iic{d}dddddc{{i}d}iic{{d}i}ddcc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{{i}d}iic{{d}i}ddccc{{i}d}iic{ddd}iccccc{iii}dc{{d}i}ddcccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddccc{{i}d}iic{ddd}icccccc{iii}dc{{d}i}ddccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddcc{{i}d}iic{ddd}iccccc{iii}dc{{d}i}ddccccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}ddc{{i}d}iic{ddd}iccccccccc{iii}dc{{d}i}ddcc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{{i}d}iic{{d}i}dd{c}cccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}dd{c}cccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}dd{c}cccc{{i}d}iic{{d}i}ddc{{i}d}iicc{{d}i}ddc{{i}d}iic{{d}i}dd{c}cccc{{i}d}iic{{d}i}ddc{{i}d}iic{{d}}{d}ddddc{{i}}{i}iiiic{{d}i}ddc{i}dddciiiiii{c}ccccddddddc{d}iiic{{i}d}iicc{{d}i}ddc{i}dddciiiiii{c}ccccddddddc{d}iiic{{i}d}iicc{{d}i}ddc{i}dddciiiiii{c}ccccddddddc{d}iiic{{i}d}iicc{{d}i}ddc{i}dddciiiiii{c}ccccddddddc{d}iiic{{i}d}iic{{d}}{d}ddddc{ii}iic{i}dddciiiiii{c}ccccccddddddc{d}iiicc{i}dddciiiiii{c}ccccccddddddc{d}iiicc{i}dddciiiiii{c}ccccccddddddc{d}iiicc{i}dddciiiiii{c}ccccccddddddc

Try it online!


text:
Output "Hello, World!" in the clipboard
Make a program (or a function) that copies the exact text "Hello, World!" to the clipboard, and terminates.

It is not a duplicate. Copying to the clipboard != Delete clipboard contents ! @Phoenix, @ DJMcMayhem

JavaScript (ES6), 19 bytes
Run in your browser's console.
copy`Hello, World!`

Mathematica, 31 bytes
CopyToClipboard@"Hello, World!"

Notepad++, 15 keystrokes
Hello, World!<C-a><C-c>

Windows command shell, 23 characters
echo Hello, World!|clip

source: Stack Exchange

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

sort: votes


text:
Slow growing Quine
Make a Quine.
Seems easy right? Well this quine must output itself plus its first character, which then outputs itself plus its second character, and so on.
This way the quine should in several generations output two copies.
Example:
Lets your code be x. Running it should output x + x[:1]. Running the resulting program should output x + x[:2] and so on...
If your code was foobar, running this should output foobarf. Running this should output foobarfo. And so on and so forth following this pattern:
foobar
foobarf
foobarfo
foobarfoo
foobarfoob
foobarfooba
foobarfoobar
foobarfoobarf

Your Program must be longer than 2 Bytes and must output only ONE extra character of its own code each iteration.

I suspect that this challenge is impossible in most languages, given that reading source code is forbidden by default.

@ØrjanJohansen and then Dennis shows up

@Rod Well I didn't say all, it's just that many/most languages have no obvious way to add arbitrary fragments of code to the end in such a way that (1) it doesn't give a syntax error (2) the program can detect the change.

Since this is a very unusual quine, are the usual quine loopholes still disallowed?

Zsh, 110 108 100 bytes
a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}
a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}

Try it online!
So it is possible.
Explanation
a=`<&0`<<''<<<t;       # Set A to everything following this line, until eof or
                       #   an empty line (which never happens before eof) encountered.
                       # A "t" is appended to prevent automatic trimming of newlines.
b=${a:0:50};           # Set B to the first line.
printf $b$b${a:0:-50}  # Print two copies of B and
                       #   A with 50 trailing characters removed.

Related: https://codegolf.stackexchange.com/q/100930/25180

R, 289 bytes
s<-c("s<-", "i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#")
i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#

credit to this quine for inspiration. Only works if run in the same R environment as the previous quine is run.

an explanation will be forthcoming...I haven't tested it 288 times yet, but I'm fairly convinced it's correct

It provably should be 289 bytes since the quine adds a newline character there but anyway its great you've solved it!

ah, you're right, stupid cat adding newlines.

But is this a full program? Are the generated code full programs?

@jimmy23013 As far as I can tell, this answer and the generated code are full programs. There is no main or any other mandatory structure like that in R. Besides, the question doesn't explicitly ask for a full program, so a function or similar would do.

Yes, even functions are allowed.

Alice, 29 bytes
4P.a+80pa2*&wdt,kd&w74*,.ok@

Try it online!
The unprintable character is 0x18.
Explanation
The trouble with the usual "-based Fungeoid quines is that if we repeat the entire source code, then we also get additional " and the string no longer covers the entire source code. I assume that's why the existing answer uses the cheat-y g approach instead.
This answer does use the "-based approach, but instead of including a " in the source, we write it into the program at runtime. That way, there will only ever be one " regardless of how often the program is repeated (because we only write it to one specific coordinate, independently of program size).
The general idea is then that we create a representation of the whole source code on the stack, but only cycle through the first 29 of the characters (i.e. the program length) with the length of the loop determined by the size of the code. Therefore, we can actually append arbitrary characters (except linefeeds) after @ and the result will always be a cyclic repetition of the core program, one character longer than the source.
4P   Push 4! = 24. This is the code point of the unprintable, which we're
     using as a placeholder for the quote.
.a+  Duplicate it and add 10, to get 34 = '"'.
80p  Write '"' to cell (8,0), i.e. where the first unprintable is.
    Placeholder, becomes " by the time we get here, and pushes the code
     points of the entire program to the stack. However, since we're already
     a good bit into the program, the order will be messed up: the bottom
     of the stack starts at the 24 (the unprintable) followed by all
     characters after it (including those from extraneous repetitions). Then
     on top we have the characters that come in front of the `"`.
     So if the initial program has structure AB, then any valid program has
     the form ABC (where C is a cyclic repetition of the initial program),
     and the stack ends up holding BCA. We don't care about C, except to
     determine how big the program is. So the first thing we need to do is
     bring B to the top, so that we've got the initial program on top of
     the stack:
a2*  Push 10*2 = 20.
&w   Run the following section 21 times, which is the length of B.

  dt,  Pull up the value at the bottom of the stack.

k    End of loop.
d&w  Run the following section D+1 times, where D is the length of ABC.

  74*  Push 28, one less than the number of characters in AB.
  ,    Pull up the 29th stack element, which is the next character to print.
  .o   Print a copy of that character.

k    End of loop.
@    Terminate the program.

Great solution. I like the explanation.

Perl 5, 83 bytes (including final newline)
$_=q($/=$;;$_="\$_=q($_);eval
__END__
".<DATA>;print$_,/(.).{82}\z/s);eval
__END__

Try it online!
The good ol' __DATA__ token makes it easy to append an arbitrary string to any Perl program, which the main program can then access via the <DATA> file handle (and actually using __END__, which does the same thing for backwards compatibility, instead of __DATA__ saves two extra bytes).
Note that this program does not read its own source code, but only the extra input data appended to its source after the __END__ token.  In effect, the __END__ token and everything after it functions kind of like a string literal terminated by the end of the input.
Also note that, in order to meet the spec exactly, this program must end in a newline.  If it does not, the newline actually gets automatically appended after the second __END__ anyway, but then the first iteration output won't be precisely equal to the code plus its first byte any more.

Befunge-98, 30 bytes
0>:#;0g:840#;+*#1-#,_$a3*%0g,@

Try it online!
My try using Befunge-98 which uses a space terminated quine which also counts how many characters have been outputed. Does however use the g command.

You might want to mention in the first line that it's non-competing/cheating, just to discourage any downvotes it might otherwise receive.

PHP, 146 bytes
ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>

It should be run using -r in command line.

Doesn't seem to work when I Try it online!, it's just an ordinary quine.

@ØrjanJohansen You should run it with php -r 'command'.

Gah, cannot get it to work. TIO seems to just ignore the -r arguments.

@ØrjanJohansen This is how you should test it.

Aha. I must have misunderstood something back then. Now I managed to get it to work with PHP as the language setting, too.

Runic Enchantments, 61 bytes
803X4+kw.'.q}͍}͍}͍}͍}͍}͍}͍}͍}͍::l͍5X-:}-$:l͍{-1--@

Try it online!
Uses a similar approach as the Alice answer: reflectively writes the string " command into the code so that there Is Only One. There rest is a lot of string and stack manipulation to recover the original program, how many extra bytes are needed, and print the necessary hunks.
The }͍ sequence rotates the in-memory string representation around so that the 803X4+kw appears at the beginning instead of at the end, due to the position of the " and there isn't an easier way of handling this operation without having to compute a lot of awkward numbers.
While the original program is 61 bytes its string-length is only 50, which is easy to construct as 5X and it was only coincidence that this didn't need to be padded out after containing all necessary functionality (e.g. a length 49 program would be easier to encode as 50 with one byte of padding than to encode a literal 49, while 51 would be encoded as 5X3+ or 53, having to account for its own extra bytes).

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/


text:
Is this a function?
Given a list of (key, value) pairs, determine whether it represents a function, meaning that each key maps to a consistent value. In other words, whenever two entries have equal keys, they must also have equal values. Repeated entries are OK.
For example:
# Not a function: 3 maps to both 1 and 6
[(3,1), (2,5), (3,6)]

# Function: It's OK that (3,5) is listed twice, and that both 6 and 4 both map to 4
[(3,5), (3,5), (6,4), (4,4)]

Input: An ordered sequence of (key, value) pairs using digits 1 to 9. You may not require a particular ordering.  You may alternatively take the key list and value list as separate inputs.
Output: A consistent value for functions, and a different consistent value for non-functions.
Test cases: The first 5 inputs are functions, the last 5 are not.
[(3, 5), (3, 5), (6, 4), (4, 4)]
[(9, 4), (1, 4), (2, 4)]
[]
[(1, 1)]
[(1, 2), (2, 1)]

[(3, 1), (2, 5), (3, 6)]
[(1, 2), (2, 1), (5, 2), (1, 2), (2, 5)]
[(8, 8), (8, 8), (8, 9), (8, 9)]
[(1, 2), (1, 3), (1, 4)]
[(1, 2), (1, 3), (2, 3), (2, 4)]

Here they are as two lists of inputs:
[[(3, 5), (3, 5), (6, 4), (4, 4)], [(9, 4), (1, 4), (2, 4)], [], [(1, 1)], [(1, 2), (2, 1)]]
[[(3, 1), (2, 5), (3, 6)], [(1, 2), (2, 1), (5, 2), (1, 2), (2, 5)], [(8, 8), (8, 8), (8, 9), (8, 9)], [(1, 2), (1, 3), (1, 4)], [(1, 2), (1, 3), (2, 3), (2, 4)]]

Leaderboard:

var QUESTION_ID=118960,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/118960/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://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

surjective function?

@Poke It doesn't have to be surjective.

Could the input be two lists of equal length, one for keys one for values?

@HelkaHomba Yes.

What is the required data range for the values?

Can the input be a flattened array like [key,value,key,value]?

@Chris Sure, go for it.

@MatteoItalia Numbers 1 to 9.

Is it OK for the (key,value) pairs to be reversed, as in (value,key)? I can shave a few bytes off my answer if so.

@ymbirtt Yes, you can have the pairs be in either order.

Python 2, 34 bytes
lambda x:len(dict(x))==len(set(x))

Try it online!
Creates a Dictionary and a Set from the input and compare their lengths.
Dictionaries can't have duplicated keys, so all the illegal (and repeated) values are removed.

Python 3, 30 bytes: lambda x:not dict(x).items()^x

lambda x:len({**x})==len({*x})

Haskell, 36 bytes
f x=and[v==n|(k,v)<-x,(m,n)<-x,k==m]

Try it online!
Outer (->(k,v)) and inner (-> (m,n)) loop over the pairs and whenever k==m, collect the truth value of v==n. Check if all are true.

You're too quick! :/

Brachylog, 5 4 bytes
dhᵐ≠

Try it online!
Full program. As far as I can tell, the reason that this is beating most other golfing languages is that ≠ is a builtin in Brachylog, whereas most of the other golfing languages need to synthesize it.
Explanation
dhᵐ≠
d     On the list of all unique elements of {the input},
 h    take the first element
  ᵐ     of each of those elements
   ≠  and assert that all those elements are different

As a full program, we get true if the assertion succeeds, or false if it fails.

Pyth, 5 bytes
I'm pretty happy with this one.
{IhM{
       implicit input
    {  removes duplicate pairs
  hM   first element of each pair
{I     checks invariance over deduplication (i.e. checks if no duplicates)

Try it online!

Retina, 25 bytes
1`({\d+,)(\d+}).*\1(?!\2)

Try it online!
Input format is {k,v},{k,v},.... Prints 0 for functions and 1 for non-functions. I could save two bytes by using linefeeds instead of the commas in the input format, but that's messed up.

I believe it qualifies as "seriously wack," at least from a technical standpoint.

Brachylog, 13 bytes
¬{⊇Ċhᵐ=∧Ċtᵐ≠}

Try it online!
Explanation
¬{          }      It is impossible...
  ⊇Ċ               ...to find a subset of length 2 of the input...
   Ċhᵐ=            ...for which both elements have the same head...
       ∧           ...and...
        Ċtᵐ≠       ...have different tails.

Can you explain how Ċhᵐ= and Ċtᵐ≠ work?

@CalculatorFeline Uppercase letters are variable names. Ċ is a special variable called Couple which is always preconstrained to be a list of two elements. ᵐ is a metapredicate which applies the immediatly previous predicate (h - head or t - tail here) to each element of the input (here, Ċ). = and ≠ simpl check that their input contains all equal/all different elements.

05AB1E, 11 9 7 bytes
Saved 2 bytes thanks to kalsowerus.
Ùø¬DÙQ,

Try it online!
Explanation
Ù           # remove duplicates
 ø          # zip
  ¬         # get the first element of the list (keys)
   D        # duplicate list of keys
    Ù       # remove duplicates in the copy
     Q      # compare for equality
      ,     # explicitly print result

@Riley: Yep. I'm still quite happy that the special case only ended up a third of the program :P

I think you could save 3 bytes by replacing \)^ with head (¬`): TIO

@kalsowerus: Unfortunately that breaks for the special case of [] :(

@Enigma Oh it worked because when testing I still had a leftover , at the end. Add that and then it somehow works with [].

Updated TIO

@kalsowerus: It does indeed work with an explicit print. Nice find :) Thanks!

MATL, 8 bytes
1Z?gs2<A

Inputs are: an array with the values, followed by an array with the keys.
Output is 1 for function, 0 otherswise.
Try it online!. Or verify all test cases.
Explanation
1Z?
Builds a sparse matrix. Initially all entries contain 0; and 1 is added to each entry (i, j) where j and i are the input key, value pairs.
g
The matrix is converted to logical; that is, entries exceeding 1 (corresponding to duplicate key, value pairs) are set to 1.
s
The sum of each column is computed. This is the number of different values for each key.
2<A
A function will have all such sums less than 2.

R, 33 bytes

This is my version for R.  This takes advantage of the ave function. I have allowed for empty input by setting defaults on the key and value parameters.  ave is producing a mean of the values for each of the keys.  Fortunately this returns the means in the same order as the input values, so a comparison to the input will indicate if there is different values.  Returns TRUE if it is a function.
function(k=0,v=0)all(ave(v,k)==v)

Try it online!

J-uby, 48 33 25 21 bytes
-3 bytes thanks to Jordan!

:size*:==%[:to_h,~:|]

Explanation
:size*:==%[:to_h,~:|]

# "readable"
(:size * :==) % [:to_h, ~:|]

# transform :% to explicit lambda
->(x){ (:size * :==).(:to_h ^ x, ~:| ^ x)

# apply explicit x to functions
->(x){ (:size * :==).(x.to_h, x|x) }

# expand :* (map over arguments)
->(x){ :==.(:size.(x.to_h), :size.(x|x) }

# simplify symbol calls to method calls
->(x){ x.to_h.size == (x|x).size }

# :| is set union for arrays; x|x just removes duplicates, like :uniq but shorter
->(x){ x.to_h.size == x.uniq.size }

First Approach, 33 bytes
-[:[]&Hash,:uniq]|:*&:size|:/&:==

This one is longer than the equivalent Ruby solution, but it was fun to make.
Attempt of explanation by transforming to Ruby:
-[:[]&Hash,:uniq]|:*&:size|:/&:==

# "readable"
-[:[] & Hash, :uniq] | (:* & :size) | (:/ & :==)

# turn into explicit lambda
->(x){ (:/ & :==) ^ ((:* & :size) ^ (-[:[] & Hash, :uniq] ^ x)) }

# simplify expressions now that we have an explicit x
->(x){ :== / (:size * [Hash[x], x.uniq]) }

# translate to equivalent Ruby code
->(x) { [Hash[x], x.uniq].map(&:size).reduce(:==) }

# simplify reduce over explicit array
->(x) { Hash[x].size == x.uniq.size }

I could save 2 bytes with a newer version by replacing :uniq with ~:|

Mathematica, 24 bytes
UnsameQ@@(#&@@@Union@#)&

Explanation: Union deletes duplicated pairs, then #&@@@ gets the first element from each pair (like First/@ but with fewer bytes). If there is any repetition in these first elements, the pairs don't make a function, which we check with UnsameQ.
(This might have the highest density of @ characters in any program I've written…)

@ density=1/4

JavaScript (ES6), 45 38 bytes
Saved 6 bytes thanks to @Neil
a=>a.some(([k,v])=>m[k]-(m[k]=v),m={})

Returns false or true for functions and non-functions, respectively.
This works by constantly subtracting the old value of each function (m[k]) and the new one (m[k]=v, which also stores the new value). Each time, there are three cases:

If there was no old value, m[k] returns undefined. Subtracting anything from undefined results in NaN, which is falsy.
If the old value is the same as the new one, m[k]-v results in 0, which is falsy.
If the old value is different from the new one, m[k]-v results in a non-zero integer, which is truthy.

Therefore, we just have to make sure that m[k]-(m[k]=v) is never truthy.

Far too long. Use a=>!a.some(([x,y])=>m[x]-(m[x]=y),m=[]).

@Neil Dang it, I knew there had to be some way to utilize m[k] being undefined... Thanks!

Actually, 4 bytes
╔♂F═

Try it online!
Explanation:
╔♂F═
╔     uniquify (remove duplicate pairs)
 ♂F   take first items in each pair (keys)
   ═  are all of the keys unique?

Jelly, 6 bytes
nþ`ḄCȦ

Try it online!
How it works
nþ`ḄCȦ  Main link. Argument: M (n×2 matrix)

nþ`     Construct the table of (a != b, c != d) with (a, b) and (c, d) in M.
   Ḅ    Unbinary; map (0, 0), (0, 1), (1, 0), (1, 1) to 0, 1, 2, 3 (resp.).
    C   Complement; map each resulting integer x to 1 - x.
     Ȧ  All; test if all resulting integers are non-zero.

05AB1E, 9 bytes
Code:
ãü-ʒ¬_}}Ë

Explanation:
ã            # Cartesian product with itself
 ü-          # Pairwise subtraction
   ʒ  }}     # Filter out elements where the following is not true:
    ¬_       #   Check whether the first digit is 0
        Ë    # Check if all equal

Uses the 05AB1E encoding. Try it online!

Getting to show off ʒ right away I see :)

@Emigna Yeah haha :p, but I already found a bug that causes me to use }} instead of }.

Bash + coreutils, 17
sort -u|uniq -dw1

Input is given via STDIN.  key and value are Tab separated and each pair is newline-delimited.
sort removes the duplicate key-value pairs.  uniq -d only outputs duplicates, and so outputs the empty string in the case of a function, and a non-empty string otherwise - when there are duplicate keys that map to different values.
Try it online.

Jelly, 6 bytes
QḢ€µQ⁼

Try it online!
Explanation
QḢ€µQ⁼
Q      - Remove duplicate pairs
 Ḣ€    - Retrieve the first element of each pair
   µ   - On the output of what came before..
     ⁼ - Are the following two equal (bit returned)?
    Q  - The output with duplicates removed
       - (implicit) the output.

Here is an alternate method, also 6 bytes:
QḢ€ṢIẠ

Try it online!
Instead of testing with removing duplicate keys, this sorts (Ṣ) and checks if the difference between terms (I) is all truthy (Ạ)

R, 36 33 bytes
function(k,v)any(v[match(k,k)]-v)

Try it online!
anonymous function; returns FALSE for functions and TRUE for not.
This is being beaten by is finally tied with MickyT's answer!!

K (ngn/k), 11 bytes
{r~?r:*'?x}

Try it online!
Port of chunes' factor answer.
Explanation
{r~?r:*'?x}

{         }     /function
        ?x      /distinct values
      *'        /first value of each
    r:          /store in r
 r~?            /is distinct?

-1 byte if you convert it to a train: ~/1?:\*'?:

APL (Dyalog), 16 12 11 9 bytes
(∪≡⊢)⊃¨∘∪

Try it online!
Explanation
∪             Unique, remove duplicates; (3 5) (3 5) => (3 5)
¨∘            For each element
⊃             Pick the first sub element (3 5) (2 3) => 3

 ≡            Check whether the arguments (listed below) are the same
  ⊢           The right argument
∪             And the right argument with duplicates removed

Prints 0 for false and 1 for true

Whoa, you're getting really good.

V, 30 bytes
Úç^¨.*©î±$/d
ÎwD
ç/HdG
Íî
Ò1lD

Try it online!
Outputs 1 for functions and nothing for non-functions.

CJam, 19 17 bytes
Saved 2 bytes thanks to Martin Ender
0l~$2ew{:.=~!&|}/

Outputs 0 for functions and 1 for non-functions.
Try it online!
Explanation
0                     e# Push a 0. We need it for later.
 l~                   e# Read and eval a line of input.
   $                  e# Sort it by the keys.
    2ew               e# Get all consecutive pairs of the sorted list.
       {              e# For each pair of pairs:
        :.=           e#  Check if the keys are equal and if the values are equal.
           ~!&        e#  Determine if the keys are equal AND the values are not equal.
              |       e#  OR with 0. If any pair indicates that the input is not a function,
                      e#  this will become 1 (and remain 1), otherwise it will be 0.
               }/     e# (end block)

R, 95 66 bytes
function(k,v)any(sapply(k,function(x){length(unique(v[k==x]))-1}))

Saved 29 bytes thanks to Jarko Dubbeldam.
Anonymous function. Outputs FALSE if a function and TRUE if not (sorry). Takes as arguments a list of keys and a list of values, like so.
> f(c(1,2,5,1,2),c(2,1,2,2,5))
[1] TRUE # not a function

Loops through all keys and grabs the length of the set of unique values for that key. If any of them are > 1, return TRUE.
This is being beaten by MickyT's answer, and also Giuseppe's. upvote one of those.

Why are you creating a dataframe, only to then reference the vectors you just put into that dataframe? function(k=0,v=0)any(sapply(k,function(x){length(unique(v[k==x]))-1})) should accomplish the same thing.

Because I'm still learning! At least one of the other R answers does it more or less like you describe.

sorry if I came off a bit harsh :) your submission is a bit different to the other R answers, and if you were to cut out the redundant data.frame, you might be able to compare better.

Mathematica, 35 bytes
(l=Length)@Union@#==l@<|Rule@@@#|>&

Pure function taking a list of ordered pairs as input and returning True or False. Exploits the fact that Union@# deletes repeated ordered pairs, but <|Rule@@@#|> (an association) deletes all but one ordered pair with a particular first element. So we can just compare the Lengths of the two outputs to check whether the input list is a function.

brainfuck, 71 bytes
,[[-[->>+<<]+>>],>[[->+<<->]<[<<]>]>[-<+>]<<[->+<]+[-<<]>>,]-[--->+<]>.

Try it online!
Input is taken as a flat string: for instance, the first test case would be 35356444.  To get the representation shown in the original question, simply add a total of six commas to the program at the right points.
Output is U for functions and V for non-functions.
Explanation
For any ASCII code point n, f(n) is stored at cell 2n+1.  Cells 2n and 2n+2 are working space, and 0, 2, 4, 6, ... 2n-2 are a trail of breadcrumbs to lead back to cell 0.  When the input is proven not to be a function, f(0) is set to 1 (among various side effects).
,                  input first key
[                  start main loop
 [-[->>+<<]+>>]    move to cell 2n, leaving a trail of breadcrumbs
 ,                 input value corresponding to current key
 >[                if key already has a value:
   [->+<<->]<      copy existing value, and compare to new value
   [<<]            if values are different, go to cell -2
   >               go back to cell 2n+1 (or -1 if mismatch)
 ]
 >[-<+>]           move existing value back to cell 2n+1 (NOP if no existing value, move the 1 from cell 0 to cell -1 if mismatch)
 <<[->+<]          copy new value to cell 2n+1 (NOP if there was already a value)
 +[-<<]>>          follow breadcrumbs back to cell 0 (NOP if mismatch)
 ,                 input next key
]                  (if mismatch, cell -2 becomes the next "cell 0", and the next key is also effectively changed by the breadcrumbs left lying around)
-[--->+<]>.        add 85 to cell 1 and output the result

Factor, 28 bytes
[ members keys all-unique? ]

Try it online!

members Get the unique elements
keys Get the keys of an associative array as a sequence
all-unique? Are they all unique?

             ! { { 1 2 } { 2 1 } { 5 2 } { 1 2 } { 2 5 } }
members      ! { { 1 2 } { 2 1 } { 5 2 } { 2 5 } }
keys         ! { 1 2 5 2 }
all-unique?  ! f

Julia, 14 bytes
!x=x⊆Dict(x)
Attempt This Online!

Desmos, 46 bytes
U=L.unique
f(L)=0^{U.length-U.x.unique.length}

Function returning 1 for functions and 0 for non-functions.
Equivalent, but slightly longer:
f(L)=0^{L.unique.length-L.unique.x.unique.length}

Try it on Desmos!

PHP, 49 bytes
foreach($_GET as[$x,$y])($$x=$$x??$y)-$y&&die(n);

Prints nothing for functions and n for non-functions.

MATL, 12 bytes
iFFvXu1Z)SdA

The input is 2-column matrix, where the first column is key and the second is value.
Try it online!
Explanation
i     % Input: 2-column matrix
FFv   % Postpend a row with two zeros. This handles the empty case
Xu    % Unique rows. This removes duplicate (key, value) pairs
1Z)   % Select first column, that is, key. We need to check if all
      % keys surviving at this point are different
S     % Sort
d     % Consecutive differences
A     % Are all values nonzero?

Perl 6, 38 bytes
!*.unique(:as(~*)).repeated(:as(*[0]))

Try it

Pyth - 9 8 bytes
ql.d{Ql{

Try it
It works by removing any repeated pairs first ({Q); then it compares the length of the list to the length of a dictionary created from the list (if the same x value occurs more than once, the dictionary constructor uses only the last one, resulting in the dictionary being shorter than the list)

JavaScript (ES6) from ETHproductions', 35 bytes
a=>a.some(([k,v])=>a[~k]-(a[~k]=v))

GolfScript, 30 17 14 12 bytes
~.|{0=}%..|=

Try it online!
Outputs 1 for true, 0 for false.
Explanation:
~.|{0=}%..|= Full program, implicit input
             Stack: "[[3 5] [3 5] [6 4] [4 4]]"
~            Evaluate input
             Stack: [[3 5] [3 5] [6 4] [4 4]]
 .|          Make unique with setwise or with itself
             Stack: [[3 5] [6 4] [4 4]]
   {0=}%     Get first element of each
             Stack: [3 6 4]
        ..|  Duplicate and make unique again
             Stack: [3 6 4] [3 6 4]
           = Compare
             Stack: 1
             Implicit output

Jelly, 5 bytes
ĠịE€Ạ

Takes input as a list of keys and a list of values.
Try it online!

Vyxal, 5 bytes
UvhÞu

Try it Online!
Port of chunes' factor answer
U     # Uniquify
 vh   # Get the first of each
   Þu # Are they all unique?

Jelly, 3 bytes
EƙẠ

Try it online!
Uses the same input format as Dennis's solution, and does almost exactly the same thing. Considering that ƙ had been implemented for half a year at that point, the only conclusion I can draw is that even he couldn't remember how the damn thing works :P
Stumbled on this because I thought of ŒṬSṠƑ, which is way funnier (directly implements the classic "vertical line test") but unfortunately errors given any empty lists.

Ruby, 39 30 29 Bytes

Thanks to @ValueInk for saving 9 bytes!
->x{Hash[x].size==(x|x).size}

Port of @Rod's Python 2 answer.

Hash[x] works just as well tbh

@ValueInk thanks. Not sure why I didn't think about that.

CJam, 14 11 9 bytes
_&0f=__&=

Try it online!
Takes input as an array of key/value pairs on the stack, returns 1 if the input is a function, and 0 if it's not.
This solution is based on the snippet _&, which de-duplicates an array by taking the set intersection of it with itself.  I do this twice, first on the full input (to get rid of any exactly duplicated key/value pairs) and then on just the keys (to see if there are any duplicate keys still left after the first de-duplication).
Here's the full code with comments:
_&           "remove duplicate key/value pairs from input";
  0f=        "remove the values, leaving only the keys";
     _       "make a copy of the array of keys";
      _&     "remove duplicate keys from the copy";
        =    "compare the de-duplicated key array with the original";

Just so you know, e# is the dedicated line comment syntax in CJam.

Ruby, 24 Bytes
->x{!x.uniq.uniq! &:pop}

Note that this only works if the points are given in [value, key] order, i.e. backwards. To be used like:
f = ->x{!x.uniq.uniq! &:pop}
p f.([[1,3], [5,2], [6,3]])
p f.([[5,3], [5,3], [4,6], [4,4]])

One of the funky quirks of uniq! is that it returns nil if no changes are made and the modified array if changes are made. If everything's already unique, you get a false-y value.
You asked for consistent values, so this gives a consistent true and false. If you're happy to just get a truthy value for one case and a falsey value for the other then we can save a byte by removing the first !.

Python 3, 32 30 29 bytes
Thanks MD XF for saving 2 bytes with a different approach, and xnor for another byte with yet another approach

lambda x:{*x}>dict(x).items()

Try it online!
Prints False for yes, True for no.
lambda x:not dict(x).items()^x

Try it online!
Also 30 bytes:
lambda x:not x-dict(x).items()

Try it online!
Alternatively (thanks xnor):
lambda x:{*x}<=dict(x).items()

Try it online!

Interesting, I did not expect dict(x).items() to allow set operations with a list. I think you can cut a byte with lambda x:{*x}>dict(x).items().

@xnor That prints False instead of True and vice versa, I'm not sure if that's allowed, and <= doesn't save a byte

@ASCII-only I'm allowing any consistent values for the two cases, based on feedback from this meta question.

@xnor well if set() is allowed as the only truthy value then I can just remove not

@ASCII-only No, in this spec the yes-values need to be consistent and the no-values also need to be be consistent.

Husk, 5 bytes
S=ü←u

Try it online!
Explanation
S=ü←u  -- example input: [(3,5),(3,5),(6,4),(4,4)]
    u  -- remove duplicates: [(3,5),(6,4),(4,4)]
S      -- is it ..
 =     -- .. equal to it
  ü    -- | remove duplicates by
   ←   -- | | first element (key): [3,6,4]
       -- | : [(3,5),(6,4),(4,4)]
       -- : 1

Alternative, 5 bytes
This one might be cheating, since it assumes that the pairs are ordered by their keys which imo would make more sense:
ΛË→ġ←

Try it online!
Explanation
Note that all non-zero integers in Husk are truthy:
ΛË→ġ←  -- example input: [(3,5),(3,5),(6,4),(4,4)]
   ġ   -- group elements by
    ←  -- | first element (key): [3,3,6,4]
       -- : [[(3,5),(3,5)],[(6,4)],[(4,4)]]
Λ      -- do all elements satisfy
 Ë     -- | all elements equal by
  →    -- | | second element (value): [[5,5],[4],[4]]
       -- : [3,2,2]
       -- : 4

Swapping ġ (groups elements that are adjacent) for k (groups even non-adjacent elements) avoids the ordering restriction for the second one...

Javascript, 41
v=>!v.some(([a,b])=>new Map(v).get(a)!=b)

const F = v=>!v.some(([a,b])=>new Map(v).get(a)!=b)

// Helper code to display test results on page

const $ = s => document.querySelector(s);

const displayArea = $("#displayArea");

const testFunctions = [
  [
    [3, 5],
    [3, 5],
    [6, 4],
    [4, 4]
  ],
  [
    [9, 4],
    [1, 4],
    [2, 4]
  ],
  [],
  [
    [1, 1]
  ],
  [
    [1, 2],
    [2, 1]
  ]
];
const testNotFunctions = [
  [
    [3, 1],
    [2, 5],
    [3, 6]
  ],
  [
    [1, 2],
    [2, 1],
    [5, 2],
    [1, 2],
    [2, 5]
  ],
  [
    [8, 8],
    [8, 8],
    [8, 9],
    [8, 9]
  ],
  [
    [1, 2],
    [1, 3],
    [1, 4]
  ],
  [
    [1, 2],
    [1, 3],
    [2, 3],
    [2, 4]
  ]
];

function println(text) {
  displayArea.append(text);
  displayArea.append(document.createElement("br"));
}

testFunctions.forEach(value => println(JSON.stringify(value) + F(value)));

println("");

testNotFunctions.forEach(value => println(JSON.stringify(value) + F(value)));

Pip -x, 10 bytes
UQa#=UQaZb

Takes input as two command-line arguments: a key list and a value list. Attempt This Online!
Explanation
UQa#=UQaZb
  a         The key list
UQ          Uniquified
   #=       Is the same length as
       a    The key list
        Z   Zipped with
         b  The value list
     UQ     Uniquified

PowerShell for Windows, 40 bytes
!($args|sort -u|group{$_[0]}|? c* -gt 1)

Try it online!
Where c* is the shortcut for the count property.

Arturo, 31 bytes
$=>[=unique<=map unique&=>last]

Try it
Takes pairs in reverse order. That is, [value,key].

Thunno 2, 6 bytes
UṬhDU⁼

(No ATO link since it's down at the moment)
Explanation
UṬhDU⁼  # Implicit input
U       # Uniquify the input
 Ṭ      # Transpose it
  h     # Get the first item
   D    # Duplicate it
    U⁼  # And check if it's all unique
        # Implicit output

Julia 1.0, 27 bytes
~x=allunique(first.(x∪x))

Try it online!

PHP, 83 Bytes
prints 1 for function and nothing for non functions

<?$r=[];foreach($_GET as$v)in_array($v,$r)?:$k[($r[]=$v)[0]]++;echo max($k?:[1])<2;

Testcases

C (gcc), 95 94 bytes
Thanks to @hvd for saving a byte!
i;r,l;f(int*k,int*v){int m[10]={0};for(r=i=0;l=k[i];++i)!m[l]?m[l]=v[i]:v[i]-m[l]?++r:0;r=!r;}

Takes input as pointers to two zero-terminated arrays.
Try it online!

You can save a byte by turning the m[l] condition to !m[l] and swapping the other operands: you can then get rid of the parentheses.

Python 2, 55 bytes
i=[j[0] for j in set(input())];print len(set(i))==len(i)

Try it online!

All you need is i=input();print len(set(i))==len(i). The list comprehension is unnecessary

You have one unnecessary space, you could shorten j[0] for to j[0]for.

JS (ES5), 75 bytes
c=function (a){m={};for(i=0;i;#_-3j@.1_#;$a1g1p

Try it online!
Input consists of zero-terminated sequence of numbers v₁ k₁ v₂ k₂ v₃ k₃ …, output is 0 if the sequence represents a function, 1 if not.
Explanation
Key-value pairs are stored in the funge space on the second row (immediately below the program code).
&:#@!#._:&:a1p1g:9`3j>;#_-3j@.1_#;$a1g1p
&                                         S: v = read()
 :# !# _                                  if v != 0 goto N
   @ #.                                   return v
         &:a1p1g                          N: k = read(), m[10] = k, w = m[k]
                 9`3j>;#_        ;        if w > 9 goto P
        :       :        -3j   _#         if v == w goto P
                            @.1           return 1
                                  $a1g1p  P: m[v] = m[10], goto S

w > 9 in the fifth line is a shortcut for w == 32 which is the value of an uninitialized cell.

Java 8, 74 bytes
This is a lambda from Iterable<int[]> or int[][] to int or Integer (1 indicates function, 0 non-function). It checks each pair of mappings for compliance.
l->{for(int[]a:l)for(int[]b:l)if(a[0]==b[0]&a[1]!=b[1])return 0;return 1;}

Try It Online

Ruby 1.9+, 20 bytes
->a{a|a==[*Hash[a]]}

In recent versions of Ruby, converting an array to a hash (dictionary) and then back preserves its order, so we can do an equality comparison instead of using .size. Otherwise this is similar to the more general Ruby answer, including the trick of removing duplicates by unioning the input array with itself.

You can also convert to hash with to.h method: 19 bytes

Nice! That's Ruby 2+, I think.


text:
Triangle and/or Square?
Explanation of the challenge
Given an input, return what shapes it could be.  There are only a couple options.

Square
Triangle

Square
A square is in the following format:
XXXX
XXXX
XXXX
XXXX

So, in this example, the input would be:
16

And the output would be:
1 or "Square"

Triangle
We are only checking for equilateral triangles:
   X
  X X
 X X X
X X X X

So, in this example, the input would be:
10

And the output would be:
2 or "Triangle"

Rules for input and output
Input must be a number.
Output can be an integer list or string list as long as you specify how your output works in your post. The output will be either a triangle, square, or both; never neither.

Test Cases
36 ->  1,2 or 3 or ["Square","Triangle"] or "Both"

15 ->  2 or "Triangle"

4  ->  1 or "Square"

Leaderboard

var QUESTION_ID=118960,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/118980/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://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

@ScottMilner  In the post I specified you could use your own output method.

The output needs to be ["Square"], as in a singleton list of the string Square? Or the string ["Square"]? Even just the string Square seems needlessly specific.

Massively updated the post to accommodate all requests.  Thanks for the input.

Possibly a dupe of Polygonal Numbers!, which asks to list all
k for a which a number is k-gonal. This restricts to k=3 and k=4.

Is it acceptable to output a 1 or 0 to indicate whether it's a square, and another 1 or 0 to indicate if it's a triangle?

Is [True, False] an OK output format (first one for triangle, second for square)?

-1 You need to make it explicitly clear what the challenge actually is. I had no idea thinking it was something about finding the area of squares and triangles

@xnor The restriction to 3 and 4 actually makes quite a difference for Retina, but I'm not sure about other languages.

Jelly, 9 7 bytes
×8‘,µÆ²

Try it online!
Outputs [1,1] for both, [0,1] for square, [1,0] for triangle, [0,0] for neither.
Explanation
×8‘,µÆ² - main link, input a
   ,    - a list of the following two:
×8‘     - a×8+1 (which is square when a is triangle)
        - (implicit) a
    µÆ² - On the previous, check if each is a square

Japt, 18 15 11 bytes
[U8*UÄ]®¬v1

Try it online!

You can save a few bytes with shortcuts: [U8*UÄ]®¬u1 ¥0 Also, u1 ¥0 can be reduced to v1 to save a couple bytes :-)

JavaScript (ES7), 40 32 bytes
Returns 1 for square, 2 for triangle, 3 for both or 0 for neither.
n=>!(n**.5%1)+2*!((8*n+1)**.5%1)

8 bytes saved in collaboration with ETHproductions and Neil.

Try It
Displays "Square/Triangle/Both/Neither" for clarity

f=
n=>!(n**.5%1)+2*!((8*n+1)**.5%1)
i.addEventListener("input",_=>o.innerText=["Neither","Square","Triangle","Both"][f(+i.value)])
<input id=i type=number>

Nice one! I think you can remove both pairs of parentheses around exponentiations (that is, n=>(n**.5%1?0:1)+((8*n+1)**.5%1?0:2). You can save another couple bytes with !(n**.5%1)

In that case, 2*!((8*n+1)**.5%1) might save a byte too.

Haskell, 49 48 37 bytes
EDIT:

-1 byte: @xnor suggested parametrizing on k.
-11 bytes: And then turned it all inside out...

f takes an integer and returns a list: [3] for square, [2] for triangle, and [2,3] for both (or [] for neither.)
f n=[k|k<-[2,3],0<-scanl(-)n[1,k..n]]

Try it online!
This uses that triangular numbers are sums 1+2+3+4+...+i while square numbers are sums 1+3+5+7+...+i, thus by starting with n and using scanl(-) to subtract either the range [1,2..n] or the range [1,3..n] consecutively, each of those cases will eventually hit 0.

Nice idea with the scan. I think it would help to write the two options as [1,k..n] for k<-[2,3].

One weird possibility is f n=[k|k<-[2,3],0<-scanl(-)n[1,k..n]].

@xnor That's starting to get pretty different, sure you don't want to post it yourself?

@xnor Someone should do it, so I'm taking silence for a no ;)

TI-BASIC, 30 23 bytes
-7 for more flexible output requirements.
:Prompt X         //Get input
:{√(X),.5+√(2X+.5 //Compute the square root of X, and the inverse of the triangular number function: X(X-1)/2
:Ans=int(Ans      //Create a list of booleans for whether the values are whole or not, then print

Takes input as an iteger.
This returns a list of integers, either 0 or 1, first for being square, then for being triangular.

Pyth - 16 bytes (possibly 13)
+*2sI@Q2sI@h*8Q2

Prints 2 if square, 1 if triangle, 3 if both, 0 if neither
Try it
Also, 19 18 17

sI@Q2sI@h*8Q2

The first line is 1 if the number is square, 0 if not.  The 2nd line is
1 if number is triangle, 0 if not.
Try it

Ohm, 15 7 bytes
D8*≥«Æ²

Try it online!
EDIT: Saved 8 bytes thanks to this Jelly answer.
Outputs [true, true] if square and triangle, [true, false] for square, and [false, true] for triangle.
Explanation:
D8*≥«Æ²  Main wire, input integer a

D        Duplicate input
 8*≥     Multiply duplicate by 8, increment
    «    Pair
     Æ²  Check if perfect square

PHP, 67 bytes
Returns 2 for square, 1 for triangle, 3 for both and 0 for none

<?=(($q=sqrt($i=$argn))==($q^0))*2+(2*$i==($x=sqrt(2*$i)^0)*$x+$x);

Try it online!

Batch, 120 bytes
@set/ar=i=j=k=0
:g
@if %j%==%1 set/ar+=1
@if %k%==%1 set/ar+=2
@set/aj+=i+=1,k=i*i
@if %j% leq %1 goto g
@echo %r%

Outputs 1 for triangular numbers, 2 for squares, 3 for both, 0 for neither.

Retina, 25 bytes
*M`(^1|1\1)+$
(^1|11\1)+$

Takes input in unary, outputs t and s on separate lines, where t and s are 0 or 1 indicating whether the shape is a triangle and/or square, respectively.
Try it online! (Contains an additional \ to put both outputs on the same line to make the test cases more easily distinguishable.)
Explanation
Triangular numbers are the sums of consecutive integers starting from one. Square numbers are the ums of consecutive odd integers starting from one. Both of those are fairly easy to match with forward references.
*M`(^1|1\1)+$

This prints 0 or 1 depending on whether the given regex matches, but it doesn't actually modify the string (the * indicates a dry run). The regex either matches the initial one with ^1 or it matches exactly one more 1 than in the previous iteration with 1\1 (the \1 refers to what (^1|1\1) matched last time).
(^1|11\1)+$

This is basically the same, except that we don't need a dry run and M is implicit. To go up by odd integers instead of all integers, we simply add two 1s on each iteration with 11\1.

C#, 61 bytes
s=n=>System.Math.Sqrt(n)%1==0;n=>(s(n)?1:0)+(s((8*n)+1)?2:0);

Could be a lot shorter if there was (or I knew) an alternative to System.Math.Sqrt.
Formatted version with test cases:
Func<int, bool> s = n => System.Math.Sqrt(n) % 1 == 0;

Func<int, int> f = n => (s(n) ? 1 : 0) + (s((8 * n) + 1) ? 2 : 0);

Console.WriteLine(f(36));
Console.WriteLine(f(15));
Console.WriteLine(f(4));
Console.WriteLine(f(2));

JavaScript (ES7), 52 bytes
Returns 1 for square, 2 for triangle, 3 for both (and 0 for none, although irrelevant).
f=(n,t=0,s=(n**.5|0)**2==n)=>t<n?f(n-++t,t,s):2*!n|s

Demo

f=(n,t=0,s=(n**.5|0)**2==n)=>t<n?f(n-++t,t,s):2*!n|s

console.log(f(7))
console.log(f(15))
console.log(f(25))
console.log(f(36))

Scoring lower than you makes me feel I've missed something!

@Shaggy I don't think so. It seems like I didn't choose the right recipe, here. Well done. :-)

Python 3, 49 42 bytes
lambda i:(i**.5%1==0)+2*((1+8*i)**.5%1==0)

Returns:

1 for Triangle
2 for Square
3 for Both

You don't need the isdigit check, input is guaranteed to be a number.

Didnt notice the change in the rules. Thanks

MATL, 11 10 bytes
t:UmGt:Ysm

Outputs two values 0 or 1 separated by newline. The first indicates if the input is square, and the second indicates if it is triangular.
Try it online!
Explanation
Consider input 4 as an example.
t     % Implicit input. Duplicate
      % STACK: 4, 4
:     % Range
      % STACK: 4, [1 2 3 4]
U     % Square, elementwise. This gives square numbers
      % STACK: 4, [1 4 9 16]
m     % Ismember
      % STACK: 1
Gt    % Push input again. Duplicate
      % STACK: 1, 4, 4
:     % Range
      % STACK: 1, 4, [1 2 3 4]
Ys    % Cumulative sum. This gives triangular numbers
      % STACK: 1, 4, [1 3 6 10]
m     % Ismember. Implicitly display
      % STACK 1, 0

Python 2, 39 bytes
lambda n:[`x**.5%1==0`for x in 8*n+1,n]

Try it online!
Outputs like ["True", "False"] for triangle then square. Probably could be shorter if allowed output format is clarified.

Bools don't seem to be covered by the output methods allowed.

@ØrjanJohansen I think it might be covered by string list? I'll ask.

I don't think this is one of the allowed outputs.

Octave, 38 bytes
@(x)~mod(x^.5,1)+2*any(x==cumsum(1:x))

Outputs 1 for square, 2 for triangular, 3 for both, 0 for neither.
Try it online!

Python 3, 72 67 bytes
x=input()
k=int((x*2)**.5)
print((x==int(x**.5)**2)+2*(2*x==k*k+k))

A bit longer than wanted. This is a full program that takes input from STDIN and outputs to STDOUT. STDERR should be empty as long as there isn't an I/O Exception and the input isn't invalid.

Why len(input)?

You can change this to Python 2 and remove the len (which I think should be int).

@Svetlana The specs were changed after I answered. Thanks for notifying me.

@pycoder ^ Thanks as well

Why is this getting downvotes?