text:
Tips for golfing in 05AB1E
Do you have any tips for code-golfing in 05AB1E, a golfing language created by Adnan?
Your tips should be at least somewhat specific to 05AB1E.
Please post one tip per answer.

From Review: Tips questions are on-topic.

Since it wasn't part of the Wiki on 05AB1E's GitHub pages (I think it should), I'm just gonna add it here now that I better understand it myself.
How to use the dictionary?
05AB1E has the following words.ex dictionary file containing all the words it knows. But how do we access the words in this dictionary? Let's take the word "testing" as example:
"testing" can be found on row 1453 of the dictionary file. Since the first two lines aren't words, and we need the 0-indexed word, we subtract 3.
So, now we have the index (1450), but how to use it?
We open and start a compressed string with “†. We then look at the second column of the info.txt file. (So € is 00; ‚ is 01; etc.)
In the case of "testing" this means î (14) and » (50).
The compressed String for "testing" is therefore: “î»“ Try it online. As with almost all 05AB1E pieces of code, the trailing “ is optional if you don't access the string, so without works as well in this case.
Some things to note:
All characters that doesn't have any index in the info.txt file can be used as is. This can be useful for adding an s to output a plural instead of singular word or use punctuation like ,.?! for example.
ÿ (string-interpolation) can also be used when you want to insert values from the stack within the string.
NOTE: Every loose character that doesn't have any index in the info.txt file counts as a word for the compression types below.
† There are different types of compressed strings you can use:

': Take a single compressed word as is (no trailing ' required) - 'î»: "testing"
„: Takes two compressed words with space delimiter (no trailing „ required) - „î»î»: "testing testing"
…: Takes three compressed words with space delimiter (no trailing … required) - …î»î»î»: "testing testing testing"
“: Take the compressed string with space delimiter - “î»î»“: "testing testing"
’: Take the compressed string as is without implicit spaces - ’î»î»’: "testingtesting"
”: Take the compressed string in title-case with space delimiter - ”î»î»”: "Testing Testing"
‘: Take the compressed string in full uppercase with space delimiter - ‘î»î»‘: "TESTING TESTING"

Here a useful program to get the compressed string based on a space-delimited input of words:
'“? lAð«Ã#¸˜ vyU "€‚ƒ„…†‡ˆ‰Š‹ŒŽ•–—™š›œžŸ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîï" Dâ vy"“ÿ“".V XlQi y?1#] '“,

Try it online.
This program will:

Take the input as lowercase, removes any non-alphabetic characters (except for spaces), and then splits the words by spaces (lAð«Ã#), or wraps the words in a list if only a single word was inputted (¸˜)
Loops over each word (vyU)
Then has an inner loop over each compressed word from the dictionary ("€...ï"Dâvy), which it will try to run as 05AB1E program ("“ÿ“".V)
And if it's equal to the current word it will print it and break the inner loop XlQiy?1#

With an input good bye world the output would therefore be “‚¿Þ¡‚ï“. Try it online.
NOTE: You'd still have to see if the word exist in the dictionary in order for this generator to work, and it will ignore any special characters or plural words. Only the words that are exactly the same in the dictionary will be found.
Here an example where I use …Ÿ™‚ï! for the string "hello world!" and ’‚¿Þ¡ ÿ ‚ï!’ for the string "goodbye ÿ world!". Note how the spaces and exclamation mark are used as is, because they don't have indices in the info.txt file. In addition, it uses ÿ to insert the "cruel" that was at the top of the stack, which unfortunately wasn't part of the dictionary (but was still compressed using the method at the section below).
How to compress strings not part of the dictionary?
Although the words.ex dictionary file is pretty big (10,000 words to be exact), it can happen that you need a word which isn't part of it, or a string which is just plain gibberish. So is there a way to compress those as well?
There certainly is, by using .•, which is a compressed base-255 alphabet based string. NOTE: This method can only be used for characters in the lowercase alphabet and spaces.
Here is a useful program to convert a word/string to the compressed base-255 alphabet based string:
vAyk})> 27β 255B ".•ÿ•"

Try it online..
What this program above does is:

vAyk})>: Take the 1-indexed alphabet indices of the individual letters of the input, with spaces becoming index 0
27β: Convert these indices from base 27 to a single number
255B: Convert this number to Base-255 using 05AB1E's own code page
".•ÿ•": Places a leading .• and trailing • before this compressed string

Here an example answer where @Kaldo uses .•zíΘ• to compress the word "goose".
How to compress large integers?
Let's say we want to use a very big number for something, but it can't really be retrieved by pow-calculations. For example, let's say we want to access the large integer 18238098189071058293 for whatever reason.
In this case we can use both a leading and trailing • to compress a number in the format [1-9][0-9]+.
The example number above will become •15Y₁Ò'Θpc•. Try it online. Again, just like with the compressed dictionary string, the trailing • can optionally be removed.
Optionally, when the integer is small enough so only 2 compressed characters have to be used, we can use Ž instead, in which case we won't need a trailing byte to close it and the integer is compressed in 3 bytes instead of 4. For example, the integer 13562 would result in •rl•, but because it only uses two characters, it can be Žrl instead.
Also, numbers in the range [101, 355] can be compressed in 2 bytes using Ƶ plus an additional character from 05AB1E's codepage. So for example, Ƶ– can be used for the integer 250. Here an overview of all available numbers. These characters are converted from Base-255 to Base-10, and then 101 is added (since the numbers in the range [0,100] are already 1 or 2 bytes).
How are these 15Y₁Ò'Θpc and rl created? Very simple, the number is converted to Base-255 using 05AB1E's own codepage. So you can use the following program to get a compressed number, for which it will then use Ƶ., Ž.., or •...• depending on the size of the compressed integer:
101 355Ÿså i 101-255B"Ƶÿ" ë 255B Dg2Qi "Žÿ" ë "•ÿ•"

Try it online.
Here an example answer where @Emigna uses •3Èñ• for the integer 246060.
How to compress integer lists?
Sometimes you want to compress an entire list of integers instead of a single number. For example, let's say we want the list [5,94,17,83,4,44,32,19,4,45,83,90,0,14,3,17,17,81] for whatever reason. In this case, we can use the following instead: •5O›YJ&p‘ÑÎ!6¯8,•₃в Try it online.
Here a useful program to generate both this compressed number and the Base we want to convert to:
Z>© β 255B ®s"•ÿ•ÿв"

Try it online.
What this program above does is:

Z>: Get the max number + 1 of the input-list (©: and store it in the register)
β: Convert the input list from base max+1 to a single number
255B: Compress this single number (as we did at the section above)
®s"•ÿ•ÿв": Returns the result in the format: leading •, compressed number, •, max+1, trailing в

Here an example answer where I use •4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91в to compress the list [85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84].
PS: In this answer •6j|eDEJÞó(ÍêΓλùÄÞKüzHÇ-ø`JδŠ₂+Öηôî®À8†6/ðÎ6ùøΓ°ÓĆ;ˆ©Ā•2ô is an equal-bytes (57) alternative, since all numbers have exactly two digits. In some cases (especially small lists) this can be a shorter alternative.
One thing to note is that it's usually shorter to use a slightly larger single-byte integer constant (i.e. T₂₆₃т₅₁₄ for 10,26,36,95,100,255,256,1000 respectively) instead of the maximum+1 found by the program above. Let's say our example [5,94,17,83,4,44,32,19,4,45,83,90,0,14,3,17,17,81] was [5,95,17,83,4,44,32,19,4,45,83,90,0,14,3,17,17,81] instead, it would find •6MÖ∊]ć;?,ćiåÑ6Š•96в (20 bytes) as shortest, but •CRā»ïζyˆöÍ†y“a±•тв (19 bytes) with the single-byte constant 100 would be 1 byte shorter.
You can still get the compressing program above by replacing the Z> with the single-byte constant (or its value): Try it online.
Integer compression vs Integer list compression:
With these two it can go either way. Sometimes a compressed list is shorter, sometimes a compressed integer, sometimes a completely different alternative is shorter. So always use your own judgment and golfing skills to possibly golf things further, instead of relying on the above generators completely. Here some examples:
[44, 59] (used in this answer of @Emigna):

•A–•60в is 7 bytes (generated by the compressed integer list generator)
•H|•2ô or •H|•2ä or hardcoded 44 59‚ are all 6 bytes
ŽH|2ô or ŽH|2ä are both 5 bytes
But in this case, „,;Ç with 4 bytes would be the best option (codepoints of characters ',' and ';')

[2,4,6,0] (used in this answer of @Emigna):

•3ā•7в is 6 bytes (generated by the compressed integer list generator)
Ž3ā7в is 5 bytes
But in this case, Ž9¦S with 4 bytes would be the best option (compressed integer 2460 to a list of digits)

10101001100101001 (initially used in this answer of mine):

•a½₄Ƶ6®í• is 9 bytes (generated by compressed large integer generator)
•1∊}•2вJ is 8 bytes (generated by compressed integer list generator with added join)
•1∊}•b with 6 bytes would be even shorter (compressed integer list, with a to binary instead of 2в, which implicitly joins)
But Ž«ǝbĆ with 5 bytes would be the shortest option here (compressed integer, to binary, and enclose - appending its own head)

[85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84] (used in this answer of mine):

•4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91в is 57 bytes (generated by compressed integer list generator)
•6j|eDEJÞó(ÍêΓλùÄÞKüzHÇ-øJδŠ₂+Öηôî®À8†6/ðÎ6ùøΓ°ÓĆ;ˆ©Ā•2ô` is also 57 bytes (compressed integer, split into parts of size 2)
•Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ
,λ₂Ï¦P(Ì•65в₂+ is however 2 bytes shorter, by compression the list with each value 26 lower, and then add that afterwards with ₂+. This trick of adding a single-byte value later on can be used pretty often to save bytes in compressed lists.

@Grimmy Missed this comment apparently, but rofl at even golfing my tip answers, haha. xD

•4βŸ{©£MG]q‡dZΘp•94в => •CHʒýo}ÚΛвÛÓĀ[ÁL•тв for -1. Yay for more tips golf x)

@Grimmy Lol, that list was just some random numbers used as an example.. xD But I've increased the 93 to 94, so the single-byte builting for 95 can be used instead, and added a note how often the single-byte integer constants can be used for shorter compressed lists. :)

Does this mean, then, that ”Ÿ™,‚ï! is a maximally compressed version of "Hello, World!"

@Someone Yep, that's indeed correct. I think you can find that exact program in the Hello, World! codegolf challenge. :)

Instead of combing through the ~10,000-line file, type input, hit enter, and wait :) Click

@Someone Thanks, but my answer above already contains a TIO that accomplishes the same basically: try it online. If the word is in the dictionary, we get the result. If not, then the result is empty.

@Someone Also, I sometimes still look through the words-file if I see partial words I could maybe combine or possibly easy modify by changing a letter so it becomes the word I was intending it to be. :) Still A for effort, though. :)

yeah. me noob. I knew that.

Using the Canvas (Λ or .Λ)
Since it wasn't part of the docs, and @Adnan is currently a bit too busy to write it, I asked permission to add it as a tip here for now.
The Canvas function (Λ or .Λ) can be used to draw ASCII-lines on the screen. It has three required parameters:

a Length: The size of the line(s). This can be a single integer, or a list of integers
b String: The character(s) we want to display. This can be a single character, a string, a list of characters, or a list of strings (in the last three cases it will use all of them one-by-one including wrap-around)
c Direction: The direction the character-lines should be drawn in. In general we have the digits [0,7] for the directions, for which we can use one or multiple. There are also some special options that require a certain character (more about that later).

The direction-digits [0,7] map to the following directions:
7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3

Some example 05AB1E answers where the Canvas is used:

Print a negative of your code
ASCII Art Octagons
Eiffel Towers: Create a large “A” from “A”s
Make an alphabet searchlight!
A nicely-spaced ASCII spiral

Let's do something similar as the last one, so assume we use the Canvas Λ function with the following three parameters:

a: [3,3,5,5,7,7,9,9]
b: !@#
c: [0,2,4,6]

This will give the following output:
  !@#!@#!
  #     @
  @ #!@ #
  ! @ # !
  # ! ! @
  @   @ #
  !#@!# !
        @
@!#@!#@!#

Try it online.
So how does it work? Well, here are the steps with these inputs above:

Draw 3 characters (!@#) upwards (direction 0)
Draw 3-1 characters (!@) towards the right (direction 2)
Draw 5-1 characters (#!@#) downwards (direction 4)
Draw 5-1 characters (!@#!) towards the left (direction 6)
Draw 7-1 characters (@#!@#!) upwards (direction 0)
Draw 7-1 characters (@#!@#!) towards the right (direction 2)
Draw 9-1 characters (@#!@#!@#) downwards (direction 4)
Draw 9-1 characters (!@#!@#!@) towards the left (direction 6)

The -1 are there because the lines overlap. So the first two steps are:
#
@
!

And
 !@

Which combined is:
#!@
@
!

Some minor notes:

Apart from the options [0,7] there are a few specific options available, which basically translate to a certain direction-sequence.

+ ('+ inline) translates to the pattern 04402662, which creates a +-cross with arms of the given length. See it in action.
× ('× inline) translates to the pattern 15513773, which creates a X-cross with arms of the given length. See it in action.
8 returns to the origin of where we started drawing from. See it in action and see the difference without the 8.

The Canvas builtin will implicitly add trailing spaces to make the output a rectangle.
The Λ will output immediately, and .Λ results a string that is pushed to the stack, which we can still re-use, modify, and do anything with that we'd want. Some examples:

We can convert it to a list of strings or to a list of characters.
We could replace a certain character
Insert a certain character
etc. etc.

Depending on the given options, either the lengths or directions are leading when drawing the output:

If a list of lengths is given, those lengths will always be leading. In this case, wrap-around can be used for the directions-list. Some examples:

lengths = [3,4] and directions = [2,3,4,5] will use directions [2,3] (the 4,5 are ignored), since only two lengths are given.
lengths = [3,4,4,2,3] and directions = [1,2] will use directions [1,2,1,2,1] since there are five given lengths.

If a single length-integer is given, the directions will be leading instead. In this case, you can't use wrap-around of the directions-list. For example:

length = 2 and directions = [3,3,5,5,7,7,1,3] will use length 2 for all directions in the list. In this case you can't remove the trailing direction 3 despite already having a leading 3, since the directions are leading for drawing the output. This would give a different output.

I wasn't even aware that 05AB1E had a canvas!

How... how did you figure this out? Source code?

@MagicOctopusUrn Most from this answer of @Adnan (PS: his latest answer is pretty well-explained as well). For the +×8 I've indeed looked in the source code.

Implicit input
Back in the days when 05AB1E was released, implicit input was quite new and fancy. Nowadays it seems to be necessary in order to keep track with other competitive languages (like Jelly, MATL, Pyth, etc.).
For example, when you want to add two numbers, you can do II+:
I    # Input_1.
 I   # Input_2.
  +  # Add them up.

Test it here

However, using implicit input, we can shorten in to just 1 byte, namely +:
+    # Take two numbers implicitly and add them up.

Test it here

This only happens when the length of the stack is smaller than the arity of the operator. A last example is 3+. The arity of the + operator is 2 while there is only 1 element in the stack:
3    # Push the number 3 on top of the stack.
 +   # Request implicit input and add to the 3.

Test it here

Predefined variables
They are a bit hidden in 05AB1E. Here's a list of all the predefined variables:

¾, pushes 0 if the counter_variable is not changed before this command.
X, pushes 1 if variable X is not changed before this command with U.
Y, pushes 2 if variable Y is not changed before this command with V.
®, pushes -1 if the register is not changed before this command with ©.
¯, pushes [] (empty array) if nothing is added to the global_array before this command.
¸, pushes [""] on an empty stack if there is no input. (Thank you @Emigna for finding this one.)

¾ pushes 0 => that's about as non-mnemonic as it gets

@Fatalize: 0 pushes 0 as well. ¾ pushes a counter variable which is initialized as 0. If you only want to push 0, 0 is of course more natural, but if you want to push 5,0,7, 5¾7 is 2 bytes shorter than 5 0 7.

Back in my day, ¾ meant .75, and I once beat Pyth with that fact. These newfangled golfing languages don't have a clue about mnemonics...

No idea what you all are talking about :p. print(3 / 4) in Python 2 gives me 0.

If at the beginning, M pushes -Inf.

@mbomb007 Yep, kinda useless though. I haven't found a case where that was needed :p.

@adnan that python comment was gold, and if this was reddit I would've given you $2.99 in gold for it lol.

Two that could perhaps be added: ˆ pushes an empty array [] (I use this one pretty often). And ¸ without input pushes an empty array filled with an empty string [""] (very conditional since most challenges have input, but I've seen it used once).

@KevinCruijssen Thanks! I've added them to the list.

@Adnan Btw, that second one was found by Emigna alone, I had nothing to do with it, except forwarding it to you ;)

) also pushes [] if the stack is empty.

@Adnan Python 2 rounds down ("integer" division) the result. Python 3 should give 0.75. (To access the old behavior, use //.)

‚ on an empty stack with no input gives ["", ""] (not sure if it's ever useful, but figured I'd mention it either way).

Substrings
£ is the command for taking the first b characters of string a.
ex: "hello_world"5£ -> "hello"
But if b is a list of indices it instead splits the string into parts of (upto) those sizes.
ex: "hello_world"5L£ -> ['h', 'el', 'lo_', 'worl', 'd']

Small 05AB1E golfing tips
Will expand this with small golfing tips I learned along the way. (Only just started 05AB1E personally.)

If you have a list of lists and first want to join each inner list by spaces, and then those space-delimited strings by newlines, the to-the-point approach would be ðý» of course. However, the » already implicitly joins inner lists by spaces before joining by newlines, so the ðý isn't necessary in this case: try it online.
D (duplicate) and Ð (triplicate) in combination with s (swap) and Š (triple-swap a,b,c to c,a,b) are usually shorter than using © (save in global_variable) and ® (push global_variable) inside loops. This saved a byte in this answer of mine, as well as two in this answer of mine.
½ (if 1, then increase counter_variable by 1) isn't necessary at the end of a µ (while counter_variable != a, do...), since it's done implicitly (saved a byte in this answer of mine).
.B implicitly splits on new-lines. This was useful in this answer of mine when we were looking for an alternative for ¡ (split) while still keeping empty items (NOTE: Solution in the linked answer doesn't work when elements contain trailing spaces after splitting.) - Hopefully a builtin will be added to split but keep empty lines in the future.
[legacy version only] SÖ (which of the digits of the input-integer can evenly divide the input-integer) will contain the number itself for the digits 0 (instead of divide-by-zero errors). For example, 1053 will result in [1,1053,0,1] (1053 is divisible by 1 and 3; is not divisible by 5; and gives a division-by-zero error for 0). This was pretty useful in this answer of mine by taking the power of the list, since only 1 is truthy in 05AB1E and everything else is falsey. SÖP resulting in truthy (1) therefore means an input-integer is evenly divisible by each of its digits.
After seeing û (palindromize a given string) I was surprised there isn't an is_palindrome builtin. But later on I realized only 2 bytes are needed to accomplish that, which are ÂQ (where Â is bifurcate, which is short for DR: Duplicate & Reverse copy; and Q is to check if the top two values on the stack are equal).
When you want to filter a list by multiple things, it's usually cheaper to have multiple loose filters, rather than all combined in one filter. Because when you have two filters you'll need something along the lines of Ds* (duplicate, swap, multiply to act as logical-AND) vs }ʒ (close first filter, filter again) when you use two filters. For example: in this challenge we have to list all numbers of four digits long, containing at least one 0, and with a digit sum equal to 9. Using a range [1000,10000] covers the number of four digits long, but then you are left with two more filters. Initially I used ₄4°ŸʒD0åsSO9Q* (14 bytes), but by using two filters a byte can be saved: ₄4°Ÿʒ0å}ʒSO9Q (13 bytes). (Which later got golfed to ₄4°ŸεW°ö9Q (10 bytes) by @Grimmy.)
When you want to zip with integer 0 as filler, you could use 0ζ. One issue with this however is that the filler 0 will become a string "0", so if you later try to sort with mixed strings and integer, this will most likely not give the result you'd want. Here an example of how it will sort the zipped inner lists: 0ζ€{. This can be fixed by adding an explicit cast to int (ï) after the zip, and only then sort: 0ζï€{. However, using the ¾ as constant 0 with the zip-filler, will cause it to remain an integer instead of a string during the zip. So ¾ζ€{ will save a byte here. This tip was provided by @Mr.Xcoder to save a byte in this answer of mine. (The same applies to X instead of 1 and Y instead of 2.)
If you want to sum the digits of multiple numbers in a list, you could use €SO. Shorter however is using 1ö, which automatically vectorizes. This tip was provided by @Grimmy to save a byte here (and 2 bytes here).
If you're only dealing with non-negative integers, and you want to get a truthy value (1) when the integer is either 0 or 1, you could of course use the obvious 2‹. However, using ! (factorial) will also only result in 1 (truthy) for 0 and 1, and every other value will result in something higher (and thus falsey, since only 1 is truthy in 05AB1E). This tip was provided by @Grimmy to save a byte here.
If you want a list of all overlapping pairs (i.e. [1,2,3,4,5,6,7,8,9] → [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],[9]]), most probably already know ü‚ can be used (Try it online). But what if you want a list of overlapping triplets or quartets? The most obvious approach would seem to be Œ3ù (substrings & keep those of length 3 - Try it online). But ü actually has a (currently undocumented) feature as shortcut for this ü3 (Try it online), which works with any integer given to ü, including 2 to create overlapping pairs (Try it online).
If the stack is empty, some builtins will use the last value that was previously on the stack (and thus there is also no implicit input!), saving you on a potential duplicate. For example, in this 05AB1E answer the × will use the 9L list twice, without a need to duplicate it first. And in this 05AB1E program the ÿ inside the string will use the 11 all three times, without the need to triplicate it first.
If we've used | to get all (remaining) inputs, the next I or implicit input will push this same list instead of the final input. Knowing this can sometimes save bytes, like in the top program of this answer of mine.
There is a flatten builtin ˜ to flatten a multi-dimensional list to a single list: try it online. There is also a way to flatten a (potentially multi-dimensional) list of strings to a single list of characters with S: try it online. But what if we only want to flatten it down one level, instead of all the way? In that case, €`  can be used if the order of items isn't important (try it online) or í€`  if retaining the order of items is important (try it online). The unordered version is used pretty often in matrix-related challenges, like I used in this answer of mine.
You probably know how δ (apply double-vectorized) can be used on two list arguments to execute it on every pair (e.g. δ‚ will create pairs using the values in the two lists - try it online). You probably also know how it can be used as an apply-map with both a list and loose argument (e.g. 0δK will remove all 0s from each inner list, which is shorter than a regular map ε0K} - try it online). What you might not know, at least it was new to me, is when two integers are given as arguments, it implicitly uses their [1,n] ranged lists instead (e.g. δ‚ again on two integer arguments will convert both to a list and applies the pairing to those - try it online). This saved two bytes in a couple of answers of mine (here and here for example).

The last tip only works if there is no input from the console. E.g. this is an example of the tip not working correctly. So this tip probably works for all 05AB1E built-ins here.

@petStorm You're right, clarified that it shouldn't have input, which is implicitly used by the stack.

Pop or get
As in other stack-based languages, 05AB1E's functions usually pop (consume) their inputs from the stack and push their outputs onto the stack.
However, some functions get their inputs from the stack without consuming them. An example is the head function, ¬, which produces the first element from the input list. See an example program here: ¬+. This adds the first number of the input list to each number of that list.
To know which functions pop and which get, see the corresponding column in the function information file.

05AB1E ASCII-Art Golfing
The below code helps turn ASCII-art into 05AB1E using a custom base conversion.
|»©ÐÙSDŠ¢øΣθ}R€н¬®sÅ?iD2£RDŠKsì}J©žLR‡®gö₅B®s"•ÿ•“ÿ“ÅвJ"

Try it online.
This is accomplished by:

Listing out the unique characters in the ASCII drawing.
Order them by how many times they occur in the string in descending order (most occurring to least occurring characters).
Reverse the first two items if the ASCII drawing starts with the most occurring character (to prevent leading 0s in the compressed integer).
Map the characters of the input to 0-9A-Za-z in that order, each distinct character getting its own mapping-character, until every one has been replaced.
Base compress it, using the highest base you needed to replace (based on the amount of unique characters).
Base convert it again to base-255 (for 05AB1E compression).
Format everything in the format: •<compressed_integer>•“<sorted_distinct_characters>“ÅвJ.

The “ allows you to also compress string-quotes "; the Åв will use this string to base-convert the generated integer using the string as custom base; and J will join all these characters together to a single string, which is output implicitly.
Accepts patterns with up to and including 62 unique characters, good for ASCII-art.
The less amount of unique characters, the better the compression.

Example output for Draw the XNOR digital timing diagram (214 bytes, 9 unique characters):
    ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐
A ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
  ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐
B ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
    ┌─────┐   ┌─┐   ┌─┐   ┌───┐
X ──┘     └───┘ └───┘ └───┘   └────

Would be:
05AB1E, 106 bytes
•I£.µ*:]ó±øqaµb₄ΘYQmœ¹µû₄p´ζÂĆ_5ŠKÑ×ðòË|₄#¹¶úôÂ-Í|¯ε¼É₂ïδ&é–9»ÞFò1î×HÃBjý2ĆÉ≠FYÂÂèC j‘£Å₅Œ•“─ └┘┐┌
XBA“ÅвJ

Try it online.
(106/214)*100 = 49.53% the size of the original ASCII-art string.
Which is the same byte-count as my actual submission for that challenge in 05AB1E (legacy).

Code explanation:
NOTE: Code is absolutely not golfed. It's quickly written to convert ASCII art to the most efficient compression, so it's quite ugly and long..
|»               # Take multi-line input
  ©              # Store it in the register to reuse later
ÐÙS              # Only leave unique characters (as list)
   DŠ¢ø          # Map it with the count for each of those characters
       Σθ}R      # Sort it based on that count (highest to lowest)
           €н    # Remove the count again, so the sorted characters remain
¬®sÅ?i           # If the input starts with the most occurring character:
      D2£RDŠKsì} #  Swap the first two characters in the list
J©               # Join everything together, and store it in the register to reuse later
  žLR‡           # Map each character to [0-9A-Za-z]
      ®gö        # Get the amount of unique characters, and convert it to that Base
         ₅B      # And then convert that to Base-255
®s               # Push the string and swap so the compressed integer is at the top again
  "•ÿ•“ÿ“ÅвJ"    # Insert it in the correct output format
                 #  `•<compressed_integer>•“<sorted_distinct_characters>“ÅвJ`
"•ÿ•"            # (after which the result is output implicitly with trailing newline)

By the way, since 05AB1E has changed the code page, the maximum base is changed from 214 to 255.

Perhaps something to add to your answer (or modify the generator with), but if less than 10 distinct characters are being used in the ASCII art, you can golf it by two bytes. I.e. your generator gives this 22-byter, but it can be this 20-byter instead.

@KevinCruijssen the idea was what I was trying to convey, not really claiming that generator is anything good :P. I honestly doubt it even still runs on osabie. I wrote that a looong time ago!

@MagicOctopusUrn Not sure if it runs in the Elixir rewrite, but it certainly still works in the legacy version. I have already edited the Base-214 to Base-255 about halve a year ago as was mention in Adnan's comment above. Apart from that it works great and I've used it a few times (although golfed it every time further. ;) ). The generation of both the string and number work great!

Here is an improved version. (Very ugly and fastly written, but it works). It would make your example 108 bytes instead of 113. The improvements I did are: sort the distinct characters on highest occurrence first (unless the highest occurrence is the first character, in which case it'll swap the top two characters) so the compressed integer is as small as possible; using <str><compr_int><int>вèJ instead of your <compr_int><int>BžLR<str>‡; and using “ instead of " as string-quotes, so " can be part of the input.

If you want I can edit your post if you don't have the time. And I might golf the code a bit more first.. I already see a few improvements without changing the actual functionality, and loads of that ugly code can be improved.. >.> But most important is that it works as intended of course.

@kevincruijssen of course feel free. 05ab1e was always a community effort for me :). Sorry ive been lurking more around space lately.

@MagicOctopusUrn Edited. :)

Implicit http://
When using .w to make requests to URLs, you may be tempted to prepend žX (the builtin for "http://") to the URL. Don't do it! According to line 239 of gen_commands.ex (general commands), if the URL does not start with http, it will automatically prepend http://. Not only that, but for URLs like http://http-server.com, while 05AB1E won't prepend http:// to http-server.com as it starts with http, HTTPoison, 05AB1E's Elixir HTTP client, will automatically prepend http:// (following the function calls all the way down to 05AB1E).

Conditionals and loops
Loops and conditionals automatically receive closing brackets at the end of a program, so you only need to add them in the code if you need to something outside of the loop/conditional.
For example, this (ungolfed) program creating a list of the first n prime numbers do not need closing brackets.
[¹¾Q#NpiNˆ¼
But if we wanted to perform some operation on the resulting list, for example taking delta's we'd need to close the loop first.
[¹¾Q#NpiNˆ¼]¯¥

Automatic vectorization
Note that some operators in 05AB1E vectorize automatically on arrays. For example, the code 5L3+, which disassembles to the following pseudocode:
[1, 2, 3, 4, 5] + 3

would become:
[4, 5, 6, 7, 8]

If it doesn't vectorize automatically, you can also use the € operator. It takes a single character command, and performs that (monadic) operator on each element. An example to split each element is the following code (try it here):
€S

Whereas the normal S operator would split each element in the array and flattens it into a single array (try it here).

How do you assign to nth element in an array?

@AndrewSavinykh Right now, there is no builtin for that, but it is something that I want to implement.

@Adnan I found a way to do it. Create another list that has the value to assign also at the nth index. Then merge the lists using ñ preceded by the value of n (the index). https://tio.run/nexus/05ab1e#@2/iw2XiE2Tio81ldHjj//8A

@mbomb007 That is possible, the only problem is that you cannot modify the array afterwards, since the merge command only takes strings as arguments (and converts the list to a string).

Ordering of the Inputs
The order that you take input can have a drastic effect on your code, and, oftentimes if you're using s to swap the top of the stack with the next highest thing on the stack, you're not thinking about the problem correctly. Try to reorder inputs and see if you can get rid of the need to swap by either swapping the inputs ahead of time, adding it to the stack earlier on or duplicating it somewhere. The most obvious I&O can be the least successful 05AB1E answer.

Strings and ints are equal types
Not something that everybody agrees with, but it works.
Consider the following two programs:
4 5+
"4""5"+

They both result into 9. That is because every value is first evaluated (with ast.literal_eval). Because of that, we can perform all string manipulation operators on ints and all int manipulation operators on strings.
For example, 12345û palindromizes the number 12345, resulting in 123454321. After that, we can do the regular math on this number.
12345û50000-

This would result into: 123404321.

Hidden loops and iterators
05AB1E has the following normal loops and iterators:

F, which iterates through 0 .. n-1.
G, which iterates through 1 .. n-1.
ƒ, which iterates through 0 .. n.
v, which iterates over each element s[0], s[1], .., s[n].
ʒ, which is not exactly a loop, but a filter-by command. We abuse this command for it's unintended behaviour of looping through each element.

Using these loops, we can derive the following hidden loops:

Instead of  gF, you can use v which also has an N-index that can be used.
The vy -> ʒ replacement is a bit more tricky:

You need to immediately print the results. This surpresses the automatic print from printing the top of the stack.
The code snippet is run on a new temporary stack. This means that stack-dependent snippets cannot be used.
Invoking y is not possible in these kind of loops.

I know this has been posted a year ago, but aren't [, µ and ε also part of the normal loops/iterations?

Also, invoking y is possible with some of these now.

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


text:
Compute the kangaroo sequence
Backstory
Disclaimer: May contain made up information about kangaroos.
Kangaroos traverse several stages of development. As they grow older and stronger, they can jump higher and longer, and they can jump more times before they get hungry.
In stage 1, the kangaroo is very little and cannot jump at all. Despite this, is constantly requires nourishment. We can represent a stage 1 kangaroo's activity pattern like this.
o

In stage 2, the kangaroo can make small jumps, but not more than 2 before it gets hungry. We can represent a stage 2 kangaroo's activity pattern like this.
 o o
o o o

After stage 2 the kangaroo improves quickly. In each subsequent stage, the kangaroo can jump a bit higher (1 unit in the graphical representation) and twice as many times. For example, a stage 3 kangaroo's activity pattern looks like this.
  o   o   o   o
 o o o o o o o o
o   o   o   o   o

All that jumping requires energy, so the kangaroo requires nourishment after completing each activity pattern. The exact amount required can be calculated as follows.

Assign each o in the activity pattern of a stage n kangaroo its height, i.e., a number from 1 to n, where 1 corresponds to the ground and n to the highest position.
Compute the sum of all heights in the activity pattern.

For example, a stage 3 kangaroo's activity pattern includes the following heights.
  3   3   3   3
 2 2 2 2 2 2 2 2
1   1   1   1   1

We have five 1's, eight 2's, and four 3's; the sum is 5·1 + 8·2 + 4·3 = 33.
Task
Write a full program or a function that takes a positive integer n as input and prints or returns the nutritional requirements per activity of a stage n kangaroo.
This is code-golf; may the shortest answer in bytes win!
Examples
 1 ->     1
 2 ->     7
 3 ->    33
 4 ->   121
 5 ->   385
 6 ->  1121
 7 ->  3073
 8 ->  8065
 9 -> 20481
10 -> 50689

I downvoted because I don't like challenges where a complicated setup comes down to a straightforward formula to golf.

While all answers so far have used the formula, I'm convinced that there are other ways to attack the problem.

Is there a challenge to generate the ascii art output of this sequence?

@miles Not sure. Kinda hard to search for.

Wolfram Alpha could not find a shorter version, http://www.wolframalpha.com/input/?i=2%5E(n-1)*(n%5E2-1)%2B1 (Weird markup because a regular URL gets messed up)

@Konijn Certain chars need to be escaped or converted to %[hex value]. Also, you should use HTTPS in your links. https://www.wolframalpha.com/input/?i=2%5E(n-1)%2A(n%5E2-1)%2B1

@miles There is now: Leaping Kangaroos

Jelly, 6 bytes
²’æ«’‘

Uses the formula (n2 - 1) 2n - 1 + 1 to compute each value. @Qwerp-Derp's was kind enough to provide a proof.
Try it online! or Verify all test cases.
Explanation
²’æ«’‘  Input: n
²       Square n
 ’      Decrement
  æ«    Bit shift left by
    ’     Decrement of n
     ‘  Increment

Did you do it by hand, or auto-generate it?

Found it using J and searching OEIS, then simplified it by hand

I consider my own answer non-competing, so I have accepted this one.

Coffeescript, 19 bytes
(n)->(n*n-1<<n-1)+1

Edit: Thanks to Dennis for chopping off 6 bytes!
The formula for generating Kangaroo numbers is this:

Explanation of formula:
The number of 1's in K(n)'s final sum is 2^(n - 1) + 1.
The number of n's in K(n)'s final sum is 2^(n - 1), so the sum of all the n's is n * 2^(n - 1).
The number of any other number (d) in K(n)'s final sum is 2^n, so the sum of all the d's would be d * 2^n.

Thus, the sum of all the other numbers = (T(n) - (n + 1)) * 2^n, where T(n) is the triangle number function (which has the formula T(n) = (n^2 + 1) / 2).
Substituting that in, we get the final sum
  (((n^2 + 1) / 2) - (n + 1)) * 2^n
= (((n + 1) * n / 2) - (n + 1)) * 2^n
= ((n + 1) * (n - 2) / 2) * 2^n
= 2^(n - 1) * (n + 1) * (n - 2)

When we add together all the sums, we get K(n), which equals
  (2^(n - 1) * (n + 1) * (n - 2)) + (2^(n - 1) + 1) + (n * 2^(n - 1))
= 2^(n - 1) * ((n + 1) * (n - 2) + n + 1) + 1
= 2^(n - 1) * ((n^2 - n - 2) + n + 1) + 1
= 2^(n - 1) * (n^2 - 1) + 1

... which is equal to the formula above.

Why does PPCG not have mathjax?

@Jonathan We did, but it caused to many problems with dollar signs in code blocks.

@JonathanAllan There were issues but it was nice for a while 1 2 3

Vanilla JS is two bytes shorter: n=>(n*n-1<<n-1)+1

Wait, MathJax doesn't work here? Or why is the equation an image?

@RudolfL.Jelínek Read Dennis's and miles's comments for details.

Java 7, 35 bytes
int c(int n){return(n*n-1<<n-1)+1;}

Jelly, 4 bytes
ŒḄ¡S

Try it online! or verify all test cases.
How it works
ŒḄ¡S  Main link. Argument: n (integer)

ŒḄ    Bounce; turn the list [a, b, ..., y, z] into [a, b, ..., y, z, y, ..., b, a].
      This casts to range, so the first array to be bounced is [1, ..., n].
      For example, 3 gets mapped to [1, 2, 3, 2, 1].
  ¡   Call the preceding atom n times.
      3 -> [1, 2, 3, 2, 1]
        -> [1, 2, 3, 2, 1, 2, 3, 2, 1]
        -> [1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1]
   S  Compute the sum.

Oh, so that's what bounce does. I wish I'd known that before adding that exact operation to Japt a few days ago :P

Python 2, 25 23 bytes
lambda x:(x*x-1<<x-1)+1

Used miles's formula.
Thanks to Jonathan Allan for -2 bytes.

You don't need ~-x. You can use x-1 as well (not any shorter), since subtraction has a higher precedence than shifting.

@mbomb007 I know, but the code Jonathan Allan gave me used ~-x, so I decided to leave it unchanged. Well, it seems everyone prefers x-1, though (Dennis also said that exact thing).

IMHO, It's more readable, and it looks more like the mathematical formula used.

@mbomb007 Oh you mean the very recently added bounty? If so, I changed it. But, I might raise some arguments then... I could have also done -~(x*x-1<<~-x) for the record, but -1 still exists, so I don't like to blend code...

I mean nothing about the bounty. The math formula used in this answer. We write "minus 1" as - 1.

@mbomb007 I didn't think there would have been be rage by 2 people about this minor thing :P I have changed it now.

Let us continue this discussion in chat.

Lua, 105 bytes
s=tonumber(arg[1])e=1 for i=1,s>1 and 2^(s-1)or 0 do e=e+1 for j=2,s-1 do e=e+j*2 end e=e+s end print(e)

De-golfed:
stage = tonumber(arg[1])
energy = 1
for i = 1, stage > 1 and 2 ^ (stage - 1) or 0 do
    energy = energy + 1
    for j = 2, stage - 1 do
        energy = energy + j * 2
    end
    energy = energy + stage
end
print(energy)

Entertaining problem!

Welcome to Programming Puzzles and Code Golf!

s=tonumber(arg[1]) can be swapped out for s=... to save some bytes. ... stores the arg table unpacked, in this case, returns arg[1]. And lua's strings will act like numbers of they only contain a valid number constructor, which we can assume the input is in this case.

CJam, 11 bytes
ri_2#(\(m<)

Try it Online.
Explanation:
r           e# Get token.       ["A"]
 i          e# Integer.         [A]
  _         e# Duplicate.       [A A]
   2#       e# Square.          [A A^2]
     (      e# Decrement.       [A A^2-1]
      \     e# Swap.            [A^2-1 A]
       (    e# Decrement.       [A^2-1 A-1]
        m<  e# Left bitshift.   [(A^2-1)*2^(A-1)]
          ) e# Increment.       [(A^2-1)*2^(A-1)+1]
            e# Implicit output.

Only if I didn't need ri...

Actually, 8 bytes
;²D@D╙*u

Try it online!
Explanation:
This simply computes the formula (n**2 - 1)*(2**(n-1)) + 1.
;²D@D╙*u
;         duplicate n
 ²        square (n**2)
  D       decrement (n**2 - 1)
   @      swap (n)
    D     decrement (n-1)
     ╙    2**(n-1)
      *   product ((n**2 - 1)*(2**(n-1)))
       u  increment ((n**2 - 1)*(2**(n-1))+1)

GolfScript, 11 bytes
~.2?(2@(?*)

Try it online!
Thanks Martin Ender (8478) for removing 4 bytes.
Explanation:
            Implicit input                 ["A"]
~           Eval                           [A]
 .          Duplicate                      [A A]
  2         Push 2                         [A A 2]
   ?        Power                          [A A^2]
    (       Decrement                      [A A^2-1]
     2      Push 2                         [A A^2-1 2]
      @     Rotate three top elements left [A^2-1 2 A]
       (    Decrement                      [A^2-1 2 A-1]
        ?   Power                          [A^2-1 2^(A-1)]
         *  Multiply                       [(A^2-1)*2^(A-1)]
          ) Increment                      [(A^2-1)*2^(A-1)+1]
            Implicit output                []

Mathematica, 15 bytes
(#*#-1)2^#/2+1&

There is no bitshift operator, so we need to do the actual exponentiation, but then it's shorter to divide by 2 instead of decrementing the exponent.

C, 26 bytes
As a macro:
#define f(x)-~(x*x-1<<~-x)

As a function (27):
f(x){return-~(x*x-1<<~-x);}

The macro version will produce incorrect results if the parameter is an expression. Consider f(1+2).

@kasperd The parameter will not be an expression. Write a full program or a function that takes a positive integer n as input and prints or returns the nutritional requirements per activity of a stage n kangaroo.

Your quote says a full program or a function. But a macro is neither.

@kasperd Basically, I think it's like a function, but without evaluation. Also, I have provided a "real" function below, if that's what you want.

05AB1E, 7 bytes
n<¹<o*>

Try it online!
Explanation
n<        # n^2
     *    # *
  ¹<o     # 2^(n-1)
      >   # + 1

MATL, 7 bytes
UqGqW*Q

Uses the formula from other answers.
Try it online!
U    % Implicit input. Square
q    % Decrement by 1
G    % Push input again
q    % Decrement by 1
W    % 2 raised to that
*    % Multiply
Q    % Increment by 1. Implicit display

C#, 18 bytes
n=>(n*n-1<<n-1)+1;

Anonymous function based on Qwerp-Derp's excellent mathematical analysis.
Full program with test cases:
using System;

namespace KangarooSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,int>f= n=>(n*n-1<<n-1)+1;

            //test cases:
            for (int i = 1; i <= 10; i++)
                Console.WriteLine(i + " -> " + f(i));
            /* will display:
            1 -> 1
            2 -> 7
            3 -> 33
            4 -> 121
            5 -> 385
            6 -> 1121
            7 -> 3073
            8 -> 8065
            9 -> 20481
            10 -> 50689
            */
        }
    }
}

Batch, 30 bytes
@cmd/cset/a"(%1*%1-1<<%1-1)+1"

Well, it beats Java anyway.

Oasis, 9 bytes
2n<mn²<*>

I'm surprised there isn't a built-in for 2^n.
Try it online!
Explanation:
2n<m        # 2^(n-1) (why is m exponentiation?)
    n²<     # n^2-1
       *    # (2^(n-1))*(n^2-1)
        >   # (2^(n-1))*(n^2-1)+1

Exponentiation in Dutch is machtsverheffing, that and lack of creativity. Also, a lot of operators haven't been implemented yet, due to lazyness and procrastination.

Racket 33 bytes
Using formula explained by @Qwerp-Derp
(+(*(expt 2(- n 1))(-(* n n)1))1)

Ungolfed:
(define (f n)
  (+ (*(expt 2
            (- n 1))
      (-(* n n)
        1))
    1))

Testing:
(for/list((i(range 1 11)))(f i))

Output:
'(1 7 33 121 385 1121 3073 8065 20481 50689)

Pyth, 8 bytes
h.<t*QQt

pyth.herokuapp.com
Explanation:
     Q   Input
      Q  Input
    *    Multiply
   t     Decrement
       t Decrement the input
 .<      Left bitshift
h        Increment

Ruby, 21 bytes
@Qwerp-Derp basically did the heavy lifting.
Because of the precedence in ruby, it seems we need some parens:
->(n){(n*n-1<<n-1)+1}

Scala, 23 bytes
(n:Int)=>(n*n-1<<n-1)+1

Uses bit shift as exponentiation

R, 26 bytes
Shamelessly applying the formula
n=scan();2^(n-1)*(n^2-1)+1

J, 11 bytes
1-<:2&*1-*:

Based on the same formula found earlier.
Try it online!
Explanation
1-<:2&*1-*:  Input: integer n
         *:  Square n
       1-    Subtract it from 1
  <:         Decrement n
    2&*      Multiply the value 1-n^2 by two n-1 times
1-           Subtract it from 1 and return

Groovy (22 Bytes)
{(it--**2-1)*2**it+1}

Does not preserve n, but uses the same formula as all others in this competition. Saved 1 byte with decrements, due to needed parenthesis.
Test
(1..10).collect{(it--**2-1)*2**it+1}

[1, 7, 33, 121, 385, 1121, 3073, 8065, 20481, 50689]

JS-Forth, 32 bytes
Not super short, but it's shorter than Java. This function pushes the result onto the stack. This requires JS-Forth because I use <<.
: f dup dup * 1- over 1- << 1+ ;

Try it online

source: Stack Exchange

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

sort: votes


text:
Prove DeMorgan's laws
Using the the ten inferences of the Natural Deduction System prove DeMorgan's laws.
The Rules of Natural Deduction

Negation Introduction: {(P → Q), (P → ¬Q)} ⊢ ¬P

Negation Elimination:  {(¬P → Q), (¬P → ¬Q)} ⊢ P

And Introduction:      {P, Q} ⊢ P ʌ Q

And Elimination:       P ʌ Q ⊢ {P, Q}

Or Introduction:       P ⊢ {(P ∨ Q),(Q ∨ P)}

Or Elimination:        {(P ∨ Q), (P → R), (Q → R)} ⊢ R

Iff Introduction:      {(P → Q), (Q → P)} ⊢ (P ≡ Q)

Iff Elimination:       (P ≡ Q) ⊢ {(P → Q), (Q → P)}

If Introduction:       (P ⊢ Q) ⊢ (P → Q)

If Elimination:        {(P → Q), P} ⊢ Q

Proof structure
Each statement in your proof must be the result of one of the ten rules applied to some previously derived propositions (no circular logic) or an assumption (described below).  Each rule operates across some propositions on the left hand side of the ⊢ (logical consequence operator) and creates any number of propositions from the right hand side.  The If Introduction works slightly differently from the rest of the operators (described in detail below).  It operates across one statement that is the logical consequent of another.
Example 1
You have the following statements:
{(P → R), Q}
You may use And Introduction to make:
(P → R) ʌ Q
Example 2
You have the following statements:
{(P → R), P}
You may use If Elimination to make:
R
Example 3
You have the following statements:
(P ʌ Q)
You may use And Elimination to make:
P
or to make:
Q
Assumption Propagation
You may at any point assume any statement you wish.  Any statement derived from these assumptions will be "reliant" on them.  Statements will also be reliant on the assumptions their parent statements rely on.  The only way to eliminate assumptions is by If Introduction.  For If introduction you start with a Statement Q that is reliant on a statement P and end with (P → Q).  The new statement is reliant on every assumption Q relies on except for assumption P.  Your final statement should rely on no assumptions.
Specifics and scoring
You will construct one proof for each of DeMorgan's two laws using only the 10 inferences of the Natural Deduction Calculus.
The two rules are:
¬(P ∨ Q) ≡ ¬P ʌ ¬Q

¬(P ʌ Q) ≡ ¬P ∨ ¬Q

Your score is the number of inferences used plus the number of assumptions made.  Your final statement should not rely on any assumptions (i.e. should be a theorem).
You are free to format your proof as you see fit.
You may carry over any Lemmas from one proof to another at no cost to score.
Example Proof
I will prove that (P and not(P)) implies Q
(Each bullet point is +1 point)

Assume not (Q)

Assume (P and not(P))

Using And Elim on (P and not(P)) derive {P, not(P)}

Use And Introduction on P and not(Q) to derive (P and not(Q))

Use And Elim on the statement just derived to make P

The new P proposition is different from the other one we derive earlier.  Namely it is reliant on the assumptions not(Q) and (P and not(P)).  Whereas the original statement was reliant only on (P and not(P)).  This allows us to do:

If Introduction on P introducing not(Q) implies P (still reliant on the (P and not(P)) assumption)

Use And Introduction on not(P) and not(Q) (from step 3) to derive (not(P) and not(Q))

Use And Elim on the statement just derived to make not(P)
(now reliant on not(Q))

If Introduction on the new not(P) introducing not(Q) implies not(P)

We will now use negation elimination on not(Q) implies not(P) and not(Q) implies P to derive Q

This Q is reliant only on the assumption (P and not(P)) so we can finish the proof with

If Introduction on Q to derive (P and not(P)) implies Q

This proof scores a total of 11.

Although the consensus on meta is clear, not everyone will have seen it yet, so this is just to highlight that proof golfing is on topic.

I think you should explain the structure of proofs and ⊢ (the symbol also doesn't render for me on mobile).

I think the explanations definitely help. What I'd find most useful would a worked and scored example of some simple proof that includes If-Introduction and assumptions, preferably nested. Maybe of contrapositive?

In your example, I believe that the first two assumptions would have to be flipped; nowhere does it state that (P ⊢ (Q ⊢ R)) ⊢ (Q ⊢ (P ⊢ R)) (in this instance, ¬Q ⊢ ((P ʌ ¬P) ⊢ P) to (P ʌ ¬P) ⊢ (¬Q ⊢ P) was used).

@LegionMammal978 the order of assumptions does not matter.  The   ⊢ operator is transitive.

@Dennis will just make a Jelly builtin and have an infinite score haha.

@TheBitByte Dennis should definitely make a Jelly builtin, but given the rules of the site he will have no score

@WheatWizard You should still state that (P ⊢ (Q ⊢ R)) ⊢ (Q ⊢ (P ⊢ R)); additionally, I can't see how you got from step 6 to step 7.

@LegionMammal978 I see your confusion. Step 7 does not follow from step 6 but rather follows from step 3. The proof is not quite linear. I will try to make this clearer

I don't understand this reliance business. For example, @feersum's proof contains assume ~P { Q ^ Q; Q; } ~P -> Q but isn't Q supposed to rely on P for this to work?

@Neil I am not sure I understand feersum's proof myself.  I am working on verifying it right now but I am having particular trouble with the portion you mention.  However it is perfectly fine for something to rest on two contradictory assumptions.

The first 2 are equivalent... because if i have one axiom formula f(a,b,c) where a b c are proposition variables than f(not a, b, c) f(a, not b, c)... f(not a, not b, not c) should be true too...

@RosLuP While your assertion is in fact true it is actually a consequent of the second axiom.  While these two axioms may seem trivially redundant, since we do not have ~(~P) -> P and cannot prove it without axiom 2 the two axioms are in fact both required.

Are you allowed to prove multiple things in a single "assumption context", and then extract multiple implication statements, to save on how many "assumption lines" are needed?  e.g. (assume (P/\~P); P,~P by and-elim; (assume ~Q; P by assumption; ~P by assumption); ~Q->P by impl-intro; ~Q->~P by impl-intro; Q by neg-elim); P/\~P->Q by impl-intro to get a score of 9?

Also, I don't see an "assumption" rule, so I'm not sure how you actually prove P -> P.  Would a proof like 1. assume P; 2. P -> P by impl-intro, 1, 1 be acceptable?  Or, to prove P -> P /\ P: would 1. { assume P; 2.   P /\ P by and-intro, 1, 1 }; 3. P -> P /\ P by impl-intro, 1, 2 be acceptable?

Score: 81
Each line should be worth 1 point. The De Morgan's laws are found at statements (3) and (6). Labels in brackets denote the previous statement(s) a line depends on if they are not immediately preceding.
(a) assume P {
    (aa) P ^ P
    (ab) P
    (ac) P v Q
} (a1) P -> P
  (a2) P -> P v Q
(1) assume ~P ^ ~Q {
    (1a) assume P v Q {
        (1aa) assume Q {
            (1aaa) assume ~P {
                (1aaaa) Q ^ Q [1aa]
                (1aaab) Q
                (1aaac) ~Q [1]
            } (1aaa1) ~P -> Q
              (1aaa2) ~P -> ~Q
            (1aab) P
        } (1aa1) Q -> P
        P [1a, a1, 1aa1]
        ~P [1]
    } (1a1) P v Q -> P
      (1a2) P v Q -> ~P
    (1b) ~(P v Q)
} (11) ~P ^ ~Q -> ~(P v Q)
(2) assume ~(P v Q) {
    (2a) ~(P v Q) ^ ~(P v Q)
    (2b) assume P {
        (2aa) ~(P v Q) [2a]
    } (2b1) P -> ~(P v Q)
    (2c) ~P [a2, 2b1]
    (2d) assume Q {
        (2da) ~(P v Q) [2a]
        (2db) P v Q
    } (2d1) Q -> ~(P v Q)
      (2d2) Q -> P v Q
    (2e) ~Q
    (2f) ~P ^ ~Q
} (21) ~(P v Q) -> ~P ^ ~Q
(3) ~(P v Q) == ~P ^ ~Q [11, 21]
(4) assume ~P v ~Q {
    (4a) assume ~P {
        (4aa) assume P ^ Q {
            (4aaa) P
            (4aab) ~P ^ ~P [4a]
            (4aac) ~P
        } (4aa1) P ^ Q -> P
          (4aa2) P ^ Q -> ~P
        (4ab) ~(P ^ Q)
    } (4a1) ~P -> ~(P ^ Q)
    (4b) assume ~Q {
        (4ba) assume P ^ Q {
            (4baa) Q
            (4bab) ~Q ^ ~Q [4b]
            (4bac) ~Q
        } (4ba1) P ^ Q -> Q
          (4ba2) P ^ Q -> ~Q
        (4bb) ~(P ^ Q)
    } (4b1) ~P -> ~(P ^ Q)
    (4c) ~(P ^ Q) [4, 4a1, 4b1]
} (41) ~P v ~Q -> ~(P ^ Q)
(5) assume ~(P ^ Q) {
    (5a) assume ~(~P v ~Q) {
        (5aa) ~(~P v ~Q) ^ ~(P ^ Q) [5, 5a]
        (5ab) assume ~P {
            (5aba) ~P v ~Q
            (5abb) ~(~P v ~Q) [5aa]
        } (5ab1) ~P -> ~P v ~Q
          (5ab2) ~P -> ~(~P v ~Q)
        (5ac) P
        (5ad) assume ~Q {
            (5ada) ~P v ~Q
            (5adb) ~(~P v ~Q) [5aa]
        } (5ad1) ~Q -> ~P v ~Q
          (5ad2) ~Q -> ~(~P v ~Q)
        (5ae) Q
        (5af) P ^ Q [5ac, 5ae]
        (5ag) ~(P ^ Q) [5aa]
    } (5a1) ~(~P v ~Q) -> P ^ Q
      (5a2) ~(~P v ~Q) -> ~(P ^ Q)
    (5b) ~P v ~Q
} (51) ~(P ^ Q) -> ~P v ~Q
(6) ~(P ^ Q) == ~P v ~Q [41, 51]

Score: 59
Explanation
I'll use a tree like structure for the proof as I find this style quite readable. Each line is annotated by the count of used rules, for example the "Example 1" in the challenge would be represented as this tree (growing bottom to top):

Note the unknown counts A,B and also the assumption Γ - so this is no theorem. To demonstrate how to prove a theorem, let us assume A and use an Or-introduction as follows:

Now this is still depending on the assumption A but we can derive a theorem by applying an If-introduction:

So we were able to derive the theorem ⊢ A → (A ∨ B) in a total of 3 steps (1 assumption & 2 applied rules).
With this we can go on to prove a few new rules that help us to prove DeMorgan's Laws.
Additional Rules
Let's first derive the Principle of Explosion and denote it with PE in further proofs:

From this we derive another form of it: A ⊢ ¬A → X - we'll call it CPE:

We'll need another one where the negated term (¬) is an assumption and refer to it as CPE-:

From the two rules we just derived (CPE and CPE-), we can derive an important rule Double Negation:

The next thing to do is to prove something like Modus Tollens - hence MT:

Lemmas
Lemma A
Lemma A1
We'll need the following rule two times:

Lemma A
By instantiating the just proved lemma twice we can show one direction of an equivalence, we will need it in the final proof:

Lemma B
In order to show another direction, we'll need to do two times some quite repetitive stuff (for both arguments A and B in (A ∨ B)) - this means here I could possibly golf the proof further..
Lemma B1'

Lemma B1

Lemma B2'

Lemma B2

Lemma B
Finally the conclusion of B1 and B2:

Actual proof
Once we proved these two statements:

Lemma A: ⊢  (A ∨ B) → ¬(¬A ʌ ¬B)
Lemma B: ⊢ ¬(A ∨ B) →  (¬A ʌ ¬B)

We can prove the first equivalence (¬(A ∨ B) ≡ ¬A ʌ ¬B)) as follows:

And with the just proved rule together with Iff-Elimination we can prove the second equivalence too:

Not sure about the score - if I did it right, let me know if there's something wrong.
Explanation
Source
If somebody wants the tex source (needs mathpartir):
In the following a rule \textbf{XYZ'} will denote the rule XYZ's second last
step, for example \textbf{PE'} will be $ A \land \lnot A \vdash X $.

\section*{Principle of Explosion [PE]}

\begin{mathpar}
  \inferrule*[Left=$\to$-Intro,Right=10]
    {\inferrule*[Left=$\lnot$-Elim,Right=9]
      {\inferrule*[Left=$\to$-Intro,Right=4]
        {\inferrule*[Left=$\land$-Elim,Right=3]
          {\inferrule*[Left=Axiom,Right=2]
            { }
            { A \land \lnot A, \lnot X \vdash A \land \lnot A }
          }
          { A \land \lnot A, \lnot X \vdash A }
        }
        { A \land \lnot A \vdash \lnot X \to A } \\
       \inferrule*[Right=$\to$-Intro,Left=4]
          {\inferrule*[Right=$\land$-Elim,Left=3]
            {\inferrule*[Right=Axiom,Left=2]
              { }
              { A \land \lnot A, \lnot X \vdash A \land \lnot A }
            }
            { A \land \lnot A, \lnot X \vdash \lnot A }
          }
        { A \land \lnot A \vdash \lnot X \to \lnot A }
      }
      { A \land \lnot A \vdash X }
    }
    { \vdash (A \land \lnot A) \to X }
\end{mathpar}

\section*{Conditioned PE [CPE]}

\begin{mathpar}
  \inferrule*[Left=$\to$-Intro,Right=5]
  {\inferrule*[Left=$\to$-Elim,Right=4]
    {\inferrule*[Left=$\land$-Intro,Right=3]
      {\inferrule*[Left=Axiom,Right=1]
        { } { A \vdash A } \\
       \inferrule*[Right=Axiom,Left=1]
        { } { \lnot A \vdash \lnot A }
      }
      { A, \lnot A \vdash A \land \lnot A } \\
     \inferrule*[Right=PE,Left=0]
      { } { \vdash (A \land \lnot A) \to X }
    }
    { A, \lnot A \vdash X }
  }
  { A \vdash \lnot A \to X }
\end{mathpar}

to get \textbf{CPE$^-$}:

\begin{mathpar}
  \inferrule*[Left=$\to$-Intro,Right=1]
    {\inferrule*[Left=CPE',Right=0]
      { }
      { A, \lnot A \vdash X }
    }
    { \lnot A \vdash A \to X }
\end{mathpar}

\section*{Double Negation [DN]}

\begin{mathpar}
  \inferrule*[Left=$\equiv$-Intro,Right=5]
    {\inferrule*[Left=$\to$-Intro,Right=2]
      {\inferrule*[Left=$\lnot$-Elim,Right=1]
        {\inferrule*[Left=CPE$^-$,Right=0]
          { }
          { \lnot\lnot A \vdash \lnot A \to X } \\
          \inferrule*[Right=CPE$^-$,Left=0]
          { }
          { \lnot\lnot A \vdash \lnot A \to \lnot X }
        }
        { \lnot\lnot A \vdash A }
      }
      { \vdash \lnot\lnot A \to A } \\ \\ \\
      \inferrule*[Left=$\to$-Intro,Right=2]
        {\inferrule*[Left=$\lnot$-Intro,Right=1]
          {\inferrule*[Left=CPE,Right=0]
            { }
            {  A \vdash \lnot A \to X } \\
            \inferrule*[Right=CPE,Left=0]
            { }
            { A \vdash \lnot A \to \lnot X }
          }
          { A \vdash \lnot\lnot A }
        }
        { \vdash A \to \lnot\lnot A }
    }
    { \vdash \lnot\lnot A \equiv A  }
\end{mathpar}

\section*{Modus Tollens [MT]}

\begin{mathpar}
  \inferrule*[Left=$\to$-Intro,Right=6]
    {\inferrule*[Left=$\lnot$-Intro,Right=5]
      {\inferrule*[Left=Axiom,Right=1]
       { }
       { A \to \lnot B \vdash A \to \lnot B } \\
       \inferrule*[Right=$\to$-Intro,Left=3]
         {\inferrule*[Right=Axiom,Left=2]
           { }
           { A, B \vdash B }
         }
         { B \vdash A \to B }
       }
      { A \to \lnot B, B \vdash \lnot A }
    }
    { A \to \lnot B \vdash B \to \lnot A }
\end{mathpar}

\section*{Lemma A}

\textbf{Lemma A1}:

\begin{mathpar}
  \inferrule*[Left=$\to$-Intro,Right=9]
    {\inferrule*[Left=$\lor$-Elim,Right=8]
       { \inferrule*[Left=CPE,Right=3]
          {\inferrule*[Left=$\land$-Elim,Right=2]
            {\inferrule*[Left=Axiom,Right=1]
              { }
              { A \land B \vdash A \land B }
            }
            { A \land B \vdash B}
          }
          { A \land B \vdash \lnot B \to X } \\
         \inferrule*[Right=CPE,Left=3]
          {\inferrule*[Right=$\land$-Elim,Left=2]
            {\inferrule*[Right=Axiom,Left=1]
              { }
              { A \land B \vdash A \land B }
            }
            { A \land B \vdash A }
          }
          { A \land B \vdash \lnot A \to X } \\ \\ \\
         \inferrule*[Right=Axiom,Left=1]
          { }
          { \lnot A \lor \lnot B \vdash \lnot A \lor \lnot B }
       }
       { A \land B, \lnot A \lor \lnot B \vdash X }
    }
    { \lnot A \lor \lnot B \vdash (A \land B) \to X }
\end{mathpar}

\textbf{Lemma A}:

As far as I can tell, the natural deduction proof system here does not allow for proving a statement once with generic proposition variables, and then instantiating it.  So, each time you have a different instantiation of one of your lemmas in terms of the variables P and Q, you would have to count its steps separately in the final total.  (In other words, the proof system doesn't directly allow proving "second-order" lemmas like "for all propositions A and B, A/\B -> B/\A" and then using it to prove both P/\(Q/\R) -> (Q/\R)/\P and (P/\Q)/\R -> R/\(P/\Q).)

@DanielSchepler: Yes but there are no circular dependencies and in the rule it states You may carry over any Lemmas from one proof to another at no cost to score., so that'll be fine. Edit: In fact if that wasn't allowed I'm certain this question would only have one eligible answer.

I was interpreting that as meaning simply that you could have some common proofs of a set of concrete formulas shared between the proofs of the two final statements.

Score: 65
The de Morgan laws are line 30 and line 65.
(I haven't made any particular effort to golf this, for example to see if there are some repeated proofs that could be abstracted out at the beginning.)
 1. assume ~(P\/Q)
 2.   assume P
 3.     P\/Q  by or-introl, 2
 4.   P -> P\/Q  by impl-intro, 2, 3
 5.   P -> ~(P\/Q)  by impl-intro, 2, 1
 6.   ~P  by neg-intro, 4, 5
 7.   assume Q
 8.     P\/Q  by or-intror, 7
 9.   Q -> P\/Q  by impl-intro, 7, 8
10.   Q -> ~(P\/Q) by impl-intro, 7, 1
11.   ~Q  by neg-intro, 9, 10
12.   ~P /\ ~Q  by and-intro, 6, 11
13. ~(P\/Q) -> ~P/\~Q  by impl-intro, 1, 12
14. assume ~P /\ ~Q
15.   ~P, ~Q  by and-elim, 14
16.   assume P \/ Q
17.     assume P
18.     P -> P  by impl-intro, 17, 17
19.     assume Q
20.       assume ~P
21.       ~P -> Q  by impl-intro, 20, 19
22.       ~P -> ~Q  by impl-intro, 20, 15
23.       P  by neg-elim, 21, 22
24.     Q -> P  by impl-intro, 19, 23
25.     P  by or-elim, 16, 18, 24
26.   P\/Q -> P  by impl-elim, 16, 25
27.   P\/Q -> ~P  by impl-elim, 16, 15
28.   ~(P\/Q)  by neg-intro, 26, 27
29. ~P/\~Q -> ~(P\/Q)  by impl-intro, 14, 28
30. ~(P\/Q) <-> ~P/\~Q  by iff-intro, 13, 29
31. assume ~(P/\Q)
32.   assume ~(~P\/~Q)
33.     assume ~P
34.       ~P\/~Q  by or-introl, 33
35.     ~P -> ~P\/~Q  by impl-intro, 33, 34
36.     ~P -> ~(~P\/~Q)  by impl-intro, 33, 32
37.     P  by neg-elim, 35, 36
38.     assume ~Q
39.       ~P\/~Q  by or-intror, 38
40.     ~Q -> ~P\/~Q  by impl-intro, 38, 39
41.     ~Q -> ~(~P\/~Q)  by impl-intro, 38, 32
42.     Q  by neg-elim, 40, 41
43.     P /\ Q  by and-intro, 37, 42
44.   ~(~P\/~Q) -> P /\ Q  by impl-intro, 32, 43
45.   ~(~P\/~Q) -> ~(P /\ Q)  by impl-intro, 32, 31
46.   ~P \/ ~Q  by neg-elim, 44, 45
47. ~(P/\Q) -> ~P\/~Q  by impl-intro, 31, 46
48. assume ~P\/~Q
49.   assume ~P
50.     assume P/\Q
51.       P, Q  by and-elim, 50
52.     P/\Q -> P  by impl-intro, 50, 51
53.     P/\Q -> ~P  by impl-intro, 50, 49
54.     ~(P/\Q)  by neg-intro, 52, 53
55.   ~P -> ~(P/\Q)  by impl-intro, 49, 54
56.   assume ~Q
57.     assume P/\Q
58.       P, Q  by and-elim, 57
59.     P/\Q -> Q  by impl-intro, 57, 58
60.     P/\Q -> ~Q  by impl-intro, 57, 56
61.     ~(P/\Q)  by neg-intro, 59, 60
62.   ~Q -> ~(P/\Q)  by impl-intro, 56, 61
63.   ~(P/\Q)  by or-elim, 48, 55, 62
64. ~P\/~Q -> ~(P/\Q)  by impl-intro, 48, 63
65. ~(P/\Q) <-> ~P\/~Q  by iff-intro, 47, 64

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


text:
Chebyshev Rotation
Consider a regular grid, where each cell has integer coordinates. We can group the cells into (square-shaped) "rings" where the cells in each ring have the same Chebyshev distance (or chessboard distance) from the origin. Your task is to take such a cell coordinate and rotate that cell by one position counter-clockwise within its ring. This implements the following mapping:

So for example if the input is (3, -2) you should output (3, -1). Note that (0, 0) is the only input that should map to itself.
Rules
The I/O format is fairly flexible. You can use two individual numbers, a pair/list/array/tuple of numbers, a single complex number, a string containing two numbers, etc.
You may assume that -128 < x,y < 128.
You may write a program or a function and use any of the our standard methods of receiving input and providing output.
You may use any programming language, but note that these loopholes are forbidden by default.
This is code-golf, so the shortest valid answer – measured in bytes – wins.
Test Cases
(0, 0)       => (0, 0)
(1, 0)       => (1, 1)
(1, 1)       => (0, 1)
(0, 1)       => (-1, 1)
(-1, 1)      => (-1, 0)
(-1, 0)      => (-1, -1)
(-1, -1)     => (0, -1)
(0, -1)      => (1, -1)
(1, -1)      => (1, 0)
(95, -12)    => (95, -11)
(127, 127)   => (126, 127)
(-2, 101)    => (-3, 101)
(-65, 65)    => (-65, 64)
(-127, 42)   => (-127, 41)
(-9, -9)     => (-8, -9)
(126, -127)  => (127, -127)
(105, -105)  => (105, -104)

Can we mix input and output format, e.g., take a tuple and output a complex number?

@Dennis yes that's fine.

JavaScript (ES6), 60 59 bytes
Takes input with currying syntax (x)(y) and returns an array [new_x, new_y].
x=>y=>(x|y&&((z=x+(y<0))>-y?z>y?y++:x--:z>y?x++:y--),[x,y])

How it works
Our main task is to determine in which quadrant we are, so that we know in which direction to move.
We can use this formula as a first approximation:
x > -y ? (x > y ? 0 : 1) : (x > y ? 2 : 3)

Here is what we get:
3 1 1 1 1 1 1 1 1
3 3 1 1 1 1 1 1 0
3 3 3 1 1 1 1 0 0
3 3 3 3 1 1 0 0 0
3 3 3 3 3 0 0 0 0
3 3 3 3 2 2 0 0 0
3 3 3 2 2 2 2 0 0
3 3 2 2 2 2 2 2 0
3 2 2 2 2 2 2 2 2

Almost there. But the bottom left and bottom right corners of the rings are invalid. We need to shift the lower half of the matrix by one position to the left, so we define z as:
z = y < 0 ? x + 1 : x

And we replace x with z in our formula:
z > -y ? (z > y ? 0 : 1) : (z > y ? 2 : 3)

Which leads to:
3 1 1 1 1 1 1 1 1
3 3 1 1 1 1 1 1 0
3 3 3 1 1 1 1 0 0
3 3 3 3 1 1 0 0 0
3 3 3 3 3 0 0 0 0
3 3 3 2 2 0 0 0 0
3 3 2 2 2 2 0 0 0
3 2 2 2 2 2 2 0 0
2 2 2 2 2 2 2 2 0

The whole matrix is now correct, except for the special case [0, 0] (no move at all) which must be addressed separately.
Test cases

let f =

x=>y=>(x|y&&((z=x+(y<0))>-y?z>y?y++:x--:z>y?x++:y--),[x,y])

console.log(f(0)(0));       // => (0, 0)
console.log(f(1)(0));       // => (1, 1)
console.log(f(1)(1));       // => (0, 1)
console.log(f(0)(1));       // => (-1, 1)
console.log(f(-1)(1));      // => (-1, 0)
console.log(f(-1)(0));      // => (-1, -1)
console.log(f(-1)(-1));     // => (0, -1)
console.log(f(0)(-1));      // => (1, -1)
console.log(f(1)(-1));      // => (1, 0)
console.log(f(95)(-12));    // => (95, -11)
console.log(f(127)(127));   // => (126, 127)
console.log(f(-2)(101));    // => (-3, 101)
console.log(f(-65)(65));    // => (-65, 64)
console.log(f(-127)(42));   // => (-127, 41)
console.log(f(-9)(-9));     // => (-8, -9)
console.log(f(126)(-127));  // => (127, -127)
console.log(f(105)(-105));  // => (105, -104)

Jelly, 20 14 12 bytes
S;IṠN0n/¦Ạ¡+

Input and output are in form of arrays. Try it online! or verify all test cases.
Background
To figure out in which direction we have to move, we can observe the relative position of the start point to the quadrant bisectors x + y = 0 (blue) and x - y = 0 (red).

The origin is fixed. We advance by adding [0, 0] to the start point.

Points in the topmost triangle – including the bisector of the first quadrant – have positive sum and non-negative delta (y - x). We advance by adding [-1, 0] to the start point.

Points in the leftmost triangle – including the bisector of the second quadrant – have non-positive sum and positive delta. We advance by adding [0, -1] to the start point.

Points in the bottommost triangle – including the bisector of the third quadrant – have negative sum and non-positive delta. We advance by adding [1, 0] to the start point.

Points in the rightmost triangle – including the bisector of the fourth quadrant – have non-negative sum and negative delta. We advance by adding [0, 1] to the start point.

To figure out the correct direction, we compute [-sign(x + y), -sign(y - x)], which has only nine possible outcomes.
The following table illustrates which outcomes have to get mapped to which directions.
    sign(x+y) |  sign(y-x) | -sign(x+y) | -sign(y-x) |     Δx     |     Δy
  ------------+------------+------------+------------+------------+------------
        0     |      0     |      0     |      0     |      0     |      0
        1     |      0     |     -1     |      0     |     -1     |      0
        1     |      1     |     -1     |     -1     |     -1     |      0
        0     |      1     |      0     |     -1     |      0     |     -1
       -1     |      1     |      1     |     -1     |      0     |     -1
       -1     |      0     |      1     |      0     |      1     |      0
       -1     |     -1     |      1     |      1     |      1     |      0
        0     |     -1     |      0     |      1     |      0     |      1
        1     |     -1     |     -1     |      1     |      0     |      1

This leaves three cases.

If at least one of the signs is 0, [Δx, Δy] = [-sign(x+y), -sign(y-x)].

If the signs are equal and non-zero, [Δx, Δy] = [-sign(x+y), 0].

If the signs are different and non-zero, [Δx, Δy] = [0, -sign(y-x)].

How it works
S;IṠN0n/¦Ạ¡+  Main link. Argument: [x, y] (pair of integers)

S             Sum; compute x + y.
  I           Increments; compute [y - x].
 ;            Concatenate; yield [x + y, y - x].
   Ṡ          Sign; compute [sign(x + y), sign(y - x)].
    N         Negate; yield [-sign(x + y), -sign(y - x)].
          ¡   Do n times:
         Ạ      Set n to all([-sign(x + y), -sign(y - x)]), i.e., 1 if the signs
                are both non-zero and 0 otherwise.
        ¦       Conditional application:
      n/          Yield 1 if the signs are not equal, 0 if they are.
     0            Replace the coordinate at 1 or 0 with a 0.
              This returns [Δx, Δy].
           +  Add; yield  [Δx + x, Δy + y].

Pyth, 19 bytes
&Q+^.jZ1.RhycPQ.n0Z

Try it online!
Translation of my Julia answer:
&Q                    If input is 0, then 0, else:
             PQ         Get phase of input
            c  .n0      Divide by π
           y            Double
          h             Add one
        .R        Z     Round to integer
   ^.jZ1                Raise i to this power
  +                     Add to input

Nice parabola answer!

Python, 55 bytes
lambda x,y:(x-(-y<x<=y)+(y<=x<-y),y+(~x<y<x)-(x<y<=-x))

Detects the four diagonal quadrants, and shifts the appropriate coordinate.

Haskell, 77 71 69 bytes
x#y|y>=x,-x<y=(x-1,y)|y>x=(x,y-1)|y< -x=(x+1,y)|y<x=(x,y+1)|1>0=(0,0)

This is just checking each of those tilted quadrants, and modifying the input accordingly. Note that the spaces are necessary, otherwise e.g. >- would be understood as an operator (which is not defined).
Thank you @nimi for removing a few more bytes!

, instead of && within the first guard saves a byte. And then you can switch the second comparison to -x<yfor another byte.

Thank you, I wasn't aware of the ,!

Ruby, 68
Lambda function takes complex number as argument, returns complex number.
->z{k=1
4.times{z*=?i.to_c
x,y=z.rect
y*y>=x*x&&y<-x&&(z+=k;k=0)}
z}

We rotate the point through 90 degrees 4 times by multiplying by i. It therefore passes through all 4 quadrants, and would be returned unchanged - except for the fact we modify it when it is in a specific one of them. The fact it is always modified in the same quadrant simplifies the modification.
It is easiest to follow if we alter it z when it is in the righthand quadrant. in this case we need to increase the y coordinate by 1 (i.e add i to z.)
We check x.abs>=y.abs by comparing the squares of x and y. This tells us the point is in the righthand or lefthand quadrant, not top or bottom. To check it is in fact in the righthand quadrant we further check that  x>y (strictly greater because we want to exclude the case x=y which belongs to the "top" quadrant.) Where this is true we add i to z.
For golfing reasons, adding i is not desirable. Instead we modifiy the number when it is in the bottom quadrant, in which case we have to add 1 to the x coordinate (add 1 to z.) In this case we test that y*y>=x*x to check it is in the top or bottom quadrant. To further ensure it is in the bottom quadrant we need to check y<-x (strictly excluding the case of the bottom right corner where y=-x.)
An advantage of this check is there is no special case for the coordinate 0,0. Unfortunately it was found that moving the point can shift it to a different quadrant and this means that a second movement must be suppressed should that quadrant be checked again, which probably negates the advantage.
Example 1
Input                                        95,-12
Rotate 90deg                                 12,95
Rotate 90deg                                -95,12
Rotate 90deg                                -12,-95
Rotate 90deg                                 95,-12
y.abs>=x.abs=TRUE, y<-x=TRUE, increase x     95,-11

The check and alteration of the coordinate is done AFTER the rotation.
Thus in this case it gets done in the 4th iteration of the loop, not the 1st.
If the code were rewritten to do the check and alteration BEFORE the rotation,
it would be done in the 1st iteration instead of the 4th.

Example 2
Input                                        -1,0
Rotate 90deg                                  0,-1
y.abs>=x.abs=TRUE, y<-x=TRUE, increase x      1,-1
Rotate 90deg                                  1,1
Rotate 90deg                                  1,-1
Rotate 90deg                                 -1,-1
y.abs>=x.abs?=TRUE, y<-x=TRUE but DO NOT CHANGE x!

This is an unusual situation due to the fact that the first move caused the
point to advance by one quadrant. We do NOT want to move it again, for this
reason we need to set k to 0 the first time it is moved.

In test program
f=->z{k=1                   #amount to be added to coordinate
4.times{z*=?i.to_c          #iterate 4 times, rotating point by 90deg till it reaches the original orientation
x,y=z.rect                  #separate out x and y for testing
y*y>=x*x&&y<-x&&(z+=k;k=0)} #if y.abs>=x.abs and y negative and not equal -x, move the point and zero k.
z}                          #return z

puts f[Complex(0, 0)]       # (0, 0)
puts f[Complex(1, 0)]       # (1, 1)
puts f[Complex(1, 1)]       # (0, 1)
puts f[Complex(0, 1)]       # (-1, 1)
puts f[Complex(-1, 1)]      # (-1, 0)
puts
puts f[Complex(-1, 0)]      # (-1, -1)
puts f[Complex(-1, -1)]     # (0, -1)
puts f[Complex(0, -1)]      # (1, -1)
puts f[Complex(1, -1)]      # (1, 0)
puts f[Complex(95, -12)]    # (95, -11)
puts f[Complex(127, 127)]   # (126, 127)
puts
puts f[Complex(-2, 101)]    # (-3, 101)
puts f[Complex(-65, 65)]    # (-65, 64)
puts f[Complex(-127, 42)]   # (-127, 41)
puts f[Complex(-9, -9)]     # (-8, -9)
puts f[Complex(126, -127)]  # (127, -127)
puts f[Complex(105, -105)]  # (105, -104)

Diagram
The following image shows (blue) the area where x*x>=y*y, (yellow) the area where y<-x and (green) the intersection of these, which is the region where the correct transformation is the addition of 1 to z.

Sorry, I'm not following the explanation. Would you mind adding either an example or a diagram?

@Martin explanation added. This was an interesting approach but due to the need to suppress double movement of points that change quadrant the first time they move, it didn´t turn out as elegant as I had hoped.

Python, 52 bytes
h=lambda z:z and 1j*h(z/1j)if'-'in`z*1j-z-1`else z+1

Complex input and output. To test the point for being in the lower diagonal quadrant, first rotate it 135 counterclockwise to move that quadrant to the (x>0, y>0) standard quadrant, and test if the result has no minus symbol in the string representation. Subtracting 1 first takes care of the boundary condition.
If it's not in that quadrant, rotate the whole problem 90 degrees. The input is zero is specially handled to output itself.
Other attempts with complex numbers:
## 56 bytes
## Coordinate input, complex output
q=lambda x,y:(y<=x<-y)*(1j*y-~x)or x+1j*y and 1j*q(y,-x)

## 60 bytes
h=lambda z:(z+1)*(z.imag<=z.real<-z.imag)or z and 1j*h(z/1j)

## 63 bytes
from cmath import*
h=lambda z:z and 1j**(phase(z*1j-z)*2//pi)+z

Julia, 38 34 bytes
!z=z==0?0:z+im^int(2angle(z)/pi+1)

Dennis saved four bytes. Thanks!
Try it online!

Looks like I mixed up int's behavior across different versions of Julia (which, in my defense, is terribly inconsistent). Julia 0.4 (the version on TIO) rounds halves towards even, so this won't work as is. In Julia 0.3, you can use int(2angle(z)/pi+5) for the same byte count (negative powers cause an error for whatever reason).

Also, you can save a byte with !z=z+(z!=0)im^... in all versions.

Mathematica, 34 bytes
±0=0
±z_:=z+I^Floor[2Arg@z/Pi+3/2]

This defines a unary operator ± which takes and returns a complex number whose components represent x and y.
Now that Lynn has revealed the complex number solution and Dennis has beaten my score, I don't feel so bad for posting my golfed referenced implementation. :) (It turns out to be virtually identical to Lynn's answer.)

Would this help?
± 0 = 0  ± z_ := z + I ^ ⌊ 2  Arg @ z / Pi + 3 / 2 ⌋
(perhaps with a different char for the floor brackets)

@DavidC unfortunately not because then I'd have to use UTF-8 encoding and then the ± would cost 2 bytes each.

Wouldn't that be 4 bytes instead of 7, thus giving an economy of 3 bytes?

@DavidC no, the floor brackets would be 3 bytes each.

I wasn't aware of that. But, even so, you should still be saving 1 byte.

@DavidC I'd save 1 for the brackets (7 -> 6) but gain 2 for ± (2 -> 4)

MATL, 19 17 bytes
t|?JGJq*X/EYP/k^+

This uses complex numbers as input and output.
Try it online! Or verify all test cases.
Explanation
Let's take input -127+42j as an example.
t|       % Implicit input. Duplicate and take absolute value
         % STACK: -127+42j, 133.764718816286
?        % If nonzero
         % STACK: -127+42j
  J      %   Push j (imaginary unit)
         %   STACK: -127+42j, j
  GJq*   %   Push input multiplied by -1+j. This adds 3*pi/4 to the phase of the input
         %   STACK: -127+42j, j, 85-169i
  X/     %   Phase of complex number
         %   STACK: -127+42j, j, -1.10478465600433
  EYP/   %   Divide by pi/2
         %   STACK: -127+42j, j, -0.703327756220671
  k      %   Round towards minus infinity
         %   STACK: -127+42j, j, -1
  ^      %   Power
         %   STACK: -127+42j, -j
  +      %   Add
         %   STACK: -127+41j
         % Implicit end
         % Implicit display

Ruby, 51 bytes
Original form
->x,y{d=x*x-y*y
[x+(d>0?0:-y<=>x),y+(d<0?0:x<=>y)]}

Alternate form per Xnor's comment
->x,y{[x+(x*x>y*y ?0:-y<=>x),y+(x*x<y*y ?0:x<=>y)]}

Uses the same type of inequalities as my other answer, but in a different way.
In test program
f=->x,y{d=x*x-y*y
[x+(d>0?0:-y<=>x), #if y.abs>=x.abs: x+=1 if -y>x, x-=1 if -y<x
y+(d<0?0:x<=>y)]}  #if x.abs>=y.abs: y+=1 if  x>y, y-=1 if  x<y

p f[0, 0]       # (0, 0)
p f[1, 0]       # (1, 1)
p f[1, 1]       # (0, 1)
p f[0, 1]       # (-1, 1)
p f[-1, 1]      # (-1, 0)
puts
p f[-1, 0]      # (-1, -1)
p f[-1, -1]     # (0, -1)
p f[0, -1]      # (1, -1)
p f[1, -1]      # (1, 0)
p f[95, -12]    # (95, -11)
p f[127, 127]   # (126, 127)
puts
p f[-2, 101]    # (-3, 101)
p f[-65, 65]    # (-65, 64)
p f[-127, 42]   # (-127, 41)
p f[-9, -9]     # (-8, -9)
p f[126, -12]   # (127, -127)
p f[105, -105]  # (105, -104)

Is the d assignment worth it? It looks like you can just compare x*x>y*y.

@Xnor unfortunately Ruby requires a space between y*y and ? so it's exactly the same length. I've included it as I think your way is in some ways neater. I think Ruby is trying to pass it as y? which would be a legal  function name.

C++, 94 bytes
#define a(x) (x>0?x:-(x))
#define f(x,y) y>a(x-.5)?x--:-y>a(x+.5)?x++:x>a(y+.5)?y++:x|y?y--:x;

Ungolfed:
#define a(x) (x>0?x:-(x))  //shorter than std::abs from <cmath>
#define f(x,y)
    y>a(x-.5)?      // shift absolute value function by 0.5 to the right to get upper fourth
        x--:
        -y>a(x+.5)? //same for lower fourth
            x++:
            x>a(y+.5)? //same for right fourth
                y++:
                x|y? //only left fourth and 0 are left
                    y--:
                    x; //can't be empty, just does nothing

Usage:
#include <iostream>
void test(int x, int y, int rx, int ry){
    std::cout << "(" << x << ", " << y << ")=>";
    f(x,y);
    std::cout << "(" << x << ", " << y << ") - " << ((x==rx&&y==ry)?"OK":"FAILURE") << std::endl;
}

//Using the test cases from the question
int main() {
    test(0, 0, 0, 0);
    test(1, 0, 1, 1);
    test(1, 1, 0, 1);
    test(0, 1, -1, 1);
    test(-1, 1, -1, 0);
    test(-1, 0, -1, -1);
    test(-1, -1, 0, -1);
    test(0, -1, 1, -1);
    test(1, -1, 1, 0);
    test(95, -12, 95, -11);
    test(127, 127, 126, 127);
    test(-2, 101, -3, 101);
    test(-65, 65, -65, 64);
    test(-127, 42, -127, 41);
    test(-9, -9, -8, -9);
    test(126, -127, 127, -127);
    test(105, -105, 105, -104);

    return 0;
}

Try it online

I'm pretty sure that (x>0?x:-(x)) can be (x>0?x:-x).

Unfortunately not, since the token x will be replaced by e.g. x+.5 which would just get -x+.5.

Alright. I had a mindset where negation without parentheses flipped the sign :D

Strictly speaking, you have used the C preprocessor (which is admittedly a part of C++, but is also shared with other C variants and descendants)

R, 131 110 bytes
A function that takes the two integers, x,y as inputs and writes the output to stdout. The solution follows @Dennis' control flow scheme but could probably be golfed.
EDIT: Updated code based on @JDL's suggestions and saved a bunch of bytes.
function(x,y){X=sign(x+y);Y=sign(y-x);if(!X|!Y){x=x-X;y=y-Y}else if(X==Y&X&Y)x=x-X else if(X-Y&X)y=y-Y;c(x,y)}

Ungolfed
f=function(x,y){
    X=sign(x+y)                 # calculate sign
    Y=sign(y-x)                 #  =||=
    if(!X|!Y){x=x-X;y=y-Y}      # if at least one is 0: subtract sign
    else if(X==Y&X&Y)x=x-X      # if signs are equal and non-zero: add sign to x
    else if(X-Y&X)y=y-Y         # if signs are not equal and non-zero: add sign to y
    c(x,y)                      # print to stdout
}

I think some of the logical conditions can be shortened: as.logical(-1) is TRUE, so X==0|Y==0 can become !X|!Y, and the condition if(X!=Y...) can become if(X-Y). Also, if X==Y and X!=0 then Y!=0 is redundant. Actually, all the !=0 parts are redundant; if(X!=0) is equivalent to if(X).

Also, given that "the I/O format is fairly flexible", it's probably fair game to output implicitly with c(x,y) instead of cat(x,y).

@JDL Those are some very useful golfing tips I never thought about, thanks alot! Updated the answer.

JavaScript (ES6), 57 bytes (55–63†)
Accepts an [x, y] array, modifies it in-place, and returns it.
c=>([x,y]=c,i=x>y|x==y&x<0,c[i^x<-y|x==-y]-=-i|!!(x|y),c)

How it works
c=>(

This is a single-parameter arrow function with a return-free concise body.
[x,y]=c

The parameter is immediately destructured into x and y variables.
,

The comma operator combines multiple expressions into one, using the result of the last.
i=x>y|x==y&x<0

i is used for differentiating increment and decrement cases. When x is greater than y, we are in either the bottom or right quadrant, and need to advance in one dimension (i=1 by boolean-to-number coercion). Likewise when we are on the negative portion of the dividing x = y diagonal. In all other cases—including the origin—no increment is required (i=0).
c[i^x<-y|x==-y]

We use a somewhat similar expression for controlling which array index to adjust. When we are incrementing and not in the left or bottom quadrants (or when we are not incrementing and in the left or bottom), then the bitwise XOR will produce 1 and we will adjust the y value. Likewise for when we are on the dividing x = -y diagonal (including the origin). In all other cases, the index will be 0 (x).
-=-i|!!(x|y)

When i is 1, we will add it to the specified value. When i is 0, we will subtract 1 from the value if and only if we are not at the origin. The latter is detected by x|y yielding nonzero, clipped to {0, 1} by boolean coercion, and the negation of i allows us to use bitwise OR instead of logical (since -1 has no zero bits, it is safe from modification).
c

The array is last, so it will be returned.
Testing

let f =
    c=>([x,y]=c,i=x>y|x==y&x<0,c[i^x<-y|x==-y]-=-i|!!(x|y),c)

let cases = `
(0, 0)       => (0, 0)
(1, 0)       => (1, 1)
(1, 1)       => (0, 1)
(0, 1)       => (-1, 1)
(-1, 1)      => (-1, 0)
(-1, 0)      => (-1, -1)
(-1, -1)     => (0, -1)
(0, -1)      => (1, -1)
(1, -1)      => (1, 0)
(95, -12)    => (95, -11)
(127, 127)   => (126, 127)
(-2, 101)    => (-3, 101)
(-65, 65)    => (-65, 64)
(-127, 42)   => (-127, 41)
(-9, -9)     => (-8, -9)
(126, -127)  => (127, -127)
(105, -105)  => (105, -104)
`;

let failures = cases.trim().split("\n").filter(l => {
    const FAIL = true;
    let m = /.*?(-?\d+).*?(-?\d+).*?(-?\d+).*?(-?\d+)/.exec(l);
    if (!m) return FAIL;
    let [_, x, y, X, Y] = m;
    let [x2, y2] = f([+x, +y]);
    if (x2==X && y2==Y) return !FAIL;
    console.log("(%s) yielded (%s); expected (%s)", [x, y], [x2, y2], [X, Y]);
    return FAIL;
});
console.log("failures: " + failures.length);
// => failures: 0

†Variations
We can save two more bytes by skipping a meaningful return value and using only the input mutation:
c=>([x,y]=c,i=x>y|x==y&x<0,c[i^x<-y|x==-y]-=-i|!!(x|y))

…or we can skip input mutation and make all variables local for a pure function, at the cost of six bytes:
([x,y],i=x>y|x==y&x<0,c=[x,y])=>(c[i^x<-y|x==-y]-=-i|!!(x|y),c)

Racket 191 bytes
(cond[(= 0 x y)(list x y)][(= x y)(if(> x 0)(list(sub1 x)y)(list(add1 x)y))][(> x y)(if(>= x(abs y))
(list x(add1 y))(list(add1 x)y))][(< x y)(if(> y(abs x))(list(sub1 x)y)(list x(sub1 y)))])

Ungolfed (directly translating figure directions to code without using any intermediate formula):
(define(f x y)
  (cond
    [(= 0 x y) (list x y)]
    [(= x y)
     (if (> x 0)
         (list (sub1 x) y)   ; left
         (list (add1 x) y))] ; right
    [(> x y)
     (if (>= x (abs y))
         (list x (add1 y))   ; up
         (list (add1 x) y))] ; right
    [(< x y)
     (if (> y (abs x))
         (list (sub1 x) y)   ; left
         (list x (sub1 y)))] ; down
    ))

Testing:
(f 0  0)
(f 1  0)
(f 1  1)
(f 0  1)
(f -1  1)
(f -1  0)
(f -1  -1)
(f 0  -1)
(f 1  -1)
(f 95  -12)
(f 127  127)
(f -2  101)
(f -65  65)
(f -127  42)
(f -9  -9)
(f 126  -127)
(f 105  -105)

Output:
'(0 0)
'(1 1)
'(0 1)
'(-1 1)
'(-1 0)
'(-1 -1)
'(0 -1)
'(1 -1)
'(1 0)
'(95 -11)
'(126 127)
'(-3 101)
'(-65 64)
'(-127 41)
'(-8 -9)
'(127 -127)
'(105 -104)

JavaScript (ES6), 80 76 bytes
(x,y,s=Math.max(x,y,-x,-y))=>(s?x+s?y-s?x-s?x++:y++:x--:y+s?y--:x++:0,[x,y])

Haskell, 53 bytes
0%0=(0,0)
x%y|y>=0-x,y<x=(x,y+1)|(p,q)<-(-y)%x=(q,-p)

Takes two numbers, outputs a tuple. If the point is in the east section -x<=y<x, increase the second coordinate by 1. Otherwise, cycle the quadrants by rotating the input point 90 degrees, calling the function on it, then rotating back.

Actually, 16 bytes
This takes a complex number as input and outputs another complex number. Golfing suggestions welcome! Try it online!
;`₧╦@/τuLïⁿ+0`╬X

Ungolfing
         Implicit input z.
;        Duplicate z.
`...`╬   If z is non-zero (any a+bi except 0+0j), run the following function.
           Stack: z, z
  ₧        Get phase(z).
  ╦@/      Divide phase(z) by pi.
  τuL      Push floor(2*phase(z)/pi + 1).
  ïⁿ       Push 1j ** floor(2*phase(z)/pi + 1).
  +        And add it to z. This is our rotated z.
  0        Push 0 to end the function.
X        Discard either the duplicate (0+0j) or the 0 from the end of function.
         Implicit return.

Scala, 184 bytes
val s=math.signum _
(x:Int,y:Int)=>{val m=x.abs max y.abs
if(x.abs==y.abs)if(s(x)==s(y))(x-s(x),y)else(x,y-s(y))else
if(x.abs==m)(x,y+Seq(0,x).indexOf(m))else(x-Seq(0,y).indexOf(m),y)}

Ungolfed:
import math._

(x: Int, y: Int) => {
  val max = max(x.abs, y.abs)
  if (x.abs == y.abs)
    if (signum(x) == signum(y))
      (x - signum(x), y)
    else
      (x, y - signum(y))
  else
    if (x.abs == max)
      (x, y + Seq(0, x).indexOf(max))
    else
      (x - Seq(0, y).indexOf(max), y)
}

Explanation:
val s=math.signum _             //define s as an alias to math.signum
(x:Int,y:Int)=>{                //define an anonymous function
  val m=x.abs max y.abs           //calculate the maximum of the absolute values,
                                  //which is 1 for the innermost circle and so on.
  if(x.abs==y.abs)                //if we have a cell at a corner of a circle
    if(s(x)==s(y))                  //if it's at the top-left or bottom-right, we need to
                                    //modify the x value
      (x-s(x),y)                      //if x is positive (bottom-right),
                                      //we need to return (x+1,y),
                                      //(x-1,y) If it's at the top-left.
                                      //This can be simplified to (x-s(x),y)
    else                            //for top-right and bottom-left,
      (x,y-s(y))                      //modify y in the same way.
  else                            //we don't have a corner piece
    if(x.abs==m)                    //if we're at the left or right edge of the square
      (x,y+Seq(0,x).indexOf(m))       //if it's a piece from the right edge, add one
                                      //to y, else subtract 1
    else                            //it's a piece from the top or bottm edge
      (x-Seq(0,y).indexOf(m),y)       //subtract 1 from x if it's from the top edge,
                                      //else subtract -1
}


text:
Real Chebyshev Rotation
This is a challenge inspired by Chebyshev Rotation. I suggest looking at answers there to get inspiration for this challenge.
Given a point on the plane there is a unique square (a rectangle with equal sides) that is centered on the origin and intersects that point (interactive demo):

Given a point p and a distance d, return the point obtained by moving distance d from p, counter-clockwise (and clockwise for negative  d), along the perimeter of the square centered on the origin that intersects p. Your answer must be accurate to at least 4 decimal digits.
Testcases:
(0, 0), 100 -> (0, 0)
(1, 1), 81.42 -> (-0.4200, 1.0000)
(42.234, 234.12), 2303.34 -> (-234.1200, 80.0940)
(-23, -39.234), -234.3 -> (39.2340, -21.8960)

The following test cases are from the original challenge by Martin Ender, and all are with d = 1:
(0, 0)       -> (0, 0)
(1, 0)       -> (1, 1)
(1, 1)       -> (0, 1)
(0, 1)       -> (-1, 1)
(-1, 1)      -> (-1, 0)
(-1, 0)      -> (-1, -1)
(-1, -1)     -> (0, -1)
(0, -1)      -> (1, -1)
(1, -1)      -> (1, 0)
(95, -12)    -> (95, -11)
(127, 127)   -> (126, 127)
(-2, 101)    -> (-3, 101)
(-65, 65)    -> (-65, 64)
(-127, 42)   -> (-127, 41)
(-9, -9)     -> (-8, -9)
(126, -127)  -> (127, -127)
(105, -105)  -> (105, -104)

Couldn't almost all of these be only slightly changed from the other challenge? This seems like a needless addition.

@ATaco No, it's quite a bit more complicated.

Should the distance be calculated along the perimeter starting at p?

@GáborFekete What else?

Yeah I see, the test cases imply this but it isn't stated explicitly. I thought at first that it would start at the positive intersection at the x-axis.

Python 2, 363 335 296 266 262 258 256 233 Bytes
Woo, 130 bytes lost! Thanks to Neil for saving 4 bytes, Nathan Merrill for saving 2 bytes, and xnor for saving a ridiculous 23 bytes!
The general idea is this: We can reduce the distance traveled by taking it's the modulus of it against the perimeter of the square. The perimeter is defined as 8 times the largest of the two coordinates, since the point must rest on it. Then, after modulus is taken we are guaranteed to have no overlap. It also guarantees we only ever have to move counter-clockwise, since modulus gives a positive result.
From there, I simply use what we know from the given x and y-coordinates to figure out where we are: top, bottom, left, right, or in a corner, and determine the direction, which can be one of 0, 1, 2, 3:
0 --> we are on the 'top', moving 'left'
1 --> we are on the 'left', moving 'down'
2 --> we are on the 'bottom', moving 'right'
3 --> we are on the 'right', moving 'up'

After this, it is as simple as looping while we still have distance to travel, and based on the direction we subtract or add to the appropriate coordinate, and tell the loop which direction we are going next.
p,d=input()
x,y=p
s=max(x,y,-x,-y)
d=d%(s*8or 1)
r=[(y<s)*[2,[3,x>-s][x<s]][y>-s],[2*(y<0),3*(y<=0)][x>0]][y*y==x*x]
while s>0<d:f=1-2*(r<2);m=abs(f*s-p[r%2]);j=d>m;p[r%2]=[p[r%2]+f*d,f*s][j];r=-~r%4;d=(d-m)*j
print"%.4f "*2%tuple(p)

While quite long, it certainly works. Here's some example I/O:
[0, 0], 100 --> 0.0000 0.0000
[1, 1], 81.42 --> -0.4200 1.0000
[42.234, 234.12], 2303.34 --> -234.1200 80.0940
[-23, -39.234], -234.3 --> 39.2340 -21.8960

Try it online or run test cases.

Does s=max(x,y,-x,-y) work?

@Neil It does, thanks a bunch!

(s>0)*(d>0) is s>0<d. The output can be "%.4f "*2%tuple(p). if s:d=d%(8*s) can be d%(s*8or 1). (r+1) can be ~-r. 1*(x>-s) can just be (x>-s). abs(y)==abs(x) can be y*y==x*x

@xnor Wow, thanks! Only thins I changed are that (x>-s) didn't need the parenthesis, and ~-r decrements, so I used -~r.

JavaScript (ES6), 147 bytes
f=(x,y,d,s=Math.max(x,y,-x,-y),c=(d/8%s+s)%s*8,v=0,w=x+y>0?1:-1,b=(v?x:y)*w+c-s)=>c?b>0?f(v?s*w:x,v?y:s*w,d,s,b,!v,v?w:-w):[x+c*w*v,y+c*w*!v]:[x,y]

Explanation: Works by trying to add the direction vector while keeping within the bounds of the square. Any overshoot is recursively passed back with the direction rotated anticlockwise by 90°. The direction is actually encoded using a vertical flag v and a unit w so that the vectors (1, 0), (0, 1), (-1, 0) and (0, -1) are encoded with v of 0, 1, 0, 1 and w of 1, 1, -1, -1 respectively. The direction vector may not initially point in a suitable direction but it never points backwards so it will eventually rotate into a usable direction.
f=(x,y,d,                   Input parameters
 s=Math.max(x,y,-x,-y),     Calculate half the side of the square
 c=(d/8%s+s)%s*8,           Reduce the distance modulo the perimeter
 v=0,                       Initial vertical flag
 w=x+y>0?1:-1,              Initial direction
 b=(v?x:y)*w+c-s)=>         Will we overshoot the corner?
  c?b>0?f(v?s*w:x,v?y:s*w,  Advance to the next corner
          d,s,b,!v,v?w:-w): Rotate the direction
        [x+c*w*v,y+c*w*!v]: Advance the remaining amout
    [x,y]                   Nothing to do, zero input

This could be because my browser (Opera 40.0.2308.81), but it looks like it has a bit of rounding error for f(42.234, 234.12, 2303.34) -> [-234.12, 80.09399999999988] meaning it doesn't have 4 digit precision. Maybe adding some output formatting would fix this? Nice answer though! :)

@Shebang Technically output formatting would require rounding, and therefore introduce a potential rounding error. The numbers generated are the closest possible within the limits of floating-point arithmetic, which should not be expected to give exact results for arbitrary decimal representations. Stick to binary fractions if you want exact answers.