[Question]
  [
# Introduction
In chess, Knights can move two squares in one direction, and then one square in an orthogonal direction. On an x/y plane, these can be thought of as being a relative change of coordinates, such as (+1, -2).
# Challenge
Your task is to output all 8 possible moves as pairs of relative x/y coordinates, in any order.
You may output in any reasonable format. To decrease reliance on printing random separators, using the same separators for everything is fine, and no separators are also fine. [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply.
**Example Outputs:**
```
1,2 1,-2 -1,-2 -1,2 2,1 2,-1 -2,-1 -2,1
2-112-2-1-211-2-1-2-1221
1;2
-1;2
2;1
2;-1
-2;-1
1;-2
-1;-2
-2;1
```
This is code golf, so fewest bytes wins.
  
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 25 bytes
```
Solve[x^2y^2==4,Integers]
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7Pzg/pyw1uiLOqDLOyNbWRMczryQ1PbWoOPZ/QFFmXolD2n8A "Wolfram Language (Mathematica) – Try It Online")
Outputs a list of `{x -> *x*, y -> *y*}`s.
[Answer]
# [Python](https://www.python.org), 30 bytes
```
print((2*"2212-1-21-2-1")[2:])
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhb7Cooy80o0NIy0lIyMDI10DXWNgEjXUEkz2sgqVhOiCKoWpgcA)
A mashup of my previous and the [trivial](https://codegolf.stackexchange.com/a/247684/107561) solutions.
# [Python](https://www.python.org), 41 bytes
```
a=1
for b in b"41030143":print(a,a:=b-50)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3NRNtDbnS8osUkhQy8xSSlEwMDYwNDE2MlawKijLzSjQSdRKtbJN0TQ00IRqg-mD6AQ)
Abuses the dual stringy/inty nature of `bytes` objects. Arranges items such that a sliding 2-window finds all required pairs.
[Answer]
# [J](http://jsoftware.com/), 18 bytes
```
(,+)@(1j2*0j1^i.4)
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/NXS0NR00DLOMtAyyDOMy9Uw0/2typSZn5CukKair/wcA "J – Try It Online")
A function taking any input and returning the list we want as complex numbers.
* `0j1^i.4` \$i\$ raised to 0, 1, 2, 3 -- gives the 4 compass directions in the complex plane: `1 0j1 _1 0j_1`.
* `1j2*` Multiply \$(1 + 2i)\$ times each of those, and we get \$(1 + 2i)\$ rotated 0, 90, 180, and 270 degrees: `1j2 _2j1 _1j_2 2j_1`.
* `(,+)` Take the complex conjugates of each of those, and append them: `1j2 _2j1 _1j_2 2j_1 1j_2 _2j_1 _1j2 2j1`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ø+pḤUƬ
```
A niladic Link that yields this pair of lists of pairs of integers:
```
[[[1, 2], [1, -2], [-1, 2], [-1, -2]], [[2, 1], [-2, 1], [2, -1], [-2, -1]]]
```
**[Try it online!](https://tio.run/##y0rNyan8///wDO2ChzuWhB5b8/8/AA)**
### How?
```
Ø+pḤUƬ - Link: no arguments
Ø+     - literal [1,-1] - set as the left argument
   Ḥ   - double -> [2,-2]
  p    - ([1,-1]) Cartesian product ([2,-2]) -> [[1,2],[1,-2],[-1,2],[-1,-2]]
     Ƭ - collect up inputs while distinct, applying:
    U  -   reverse each
```
---
Original seven byter (not abusing the very lose IO):
```
Ø+pḤ;U$ - Link: no arguments
Ø+      - literal [1,-1] - set as the left argument
   Ḥ    - double -> [2,-2]
  p     - ([1,-1]) Cartesian product ([2,-2]) -> [[1,2],[1,-2],[-1,2],[-1,-2]]
      $ - last two links as a monad - f(X=that):
     U  -   reverse each of (X)
    ;   -   (X) concatenate (that)
```
[Try it online!](https://tio.run/##y0rNyan8///wDO2ChzuWWIeq/P8PAA "Jelly – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~9~~ 8 bytes
```
Ø+p×Ø½UƬ
```
[Try it online!](https://tio.run/##y0rNyan8///wDO2Cw9MPzzi0N/TYmv//AQ "Jelly – Try It Online")
*-1 by stretching the output format a bit*
```
Ø+p         Cartesian product of [1, -1] with itself.
   ×Ø½      Multiply each pair with [1, 2],
      UƬ    and pair with the reversed pairs.
```
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
ı*Ɱ4×2ıṠƬ
```
[Try it online!](https://tio.run/##ARoA5f9qZWxsef//xLEq4rGuNMOXMsSx4bmgxqz//w "Jelly – Try It Online")
Port of [Jonah's J solution](https://codegolf.stackexchange.com/a/247680/85334).
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
“ç©Ḅ’b5_2ṡ2
```
[Try it online!](https://tio.run/##AR4A4f9qZWxsef//4oCcw6fCqeG4hOKAmWI1XzLhuaEy//8 "Jelly – Try It Online")
Port of [loopy walt's Python solution](https://codegolf.stackexchange.com/a/247681/85334).
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
“œƇØj_’ṃ“21-
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5yjk4@1H56RFf@oYebDnc1AASND3f//AQ "Jelly – Try It Online")
A fully hardcoded, no separator solution for comparison.
[Answer]
# [Factor](https://factorcode.org/) + `math.combinatorics math.unicode`, 47 bytes
```
{ 1 -1 2 -2 } 2 selections [ Σ odd? ] filter .
```
[Try it online!](https://tio.run/##JcgxDoJAEEbhq/wXgARKLSiNjY2xMhbr7BAngR3cGQpiOI338Uor0erlfX0g11wu5@PpsMMY/FGTjndJYWMh@9OchDTyb2D8nDkRG6bM7suUJTn25YUGVYMWVYt1i/HA5KLJcMXnDY2xww29DM4ZdSlf "Factor – Try It Online")
## How?
Generate all 2-selections of `{ 1 -1 2 -2 }`:
```
{ 1 1 }
{ 1 -1 }
{ 1 2 }
{ 1 -2 }
{ -1 1 }
{ -1 -1 }
{ -1 2 }
{ -1 -2 }
{ 2 1 }
{ 2 -1 }
{ 2 2 }
{ 2 -2 }
{ -2 1 }
{ -2 -1 }
{ -2 2 }
{ -2 -2 }
```
and keep only those with odd sums:
```
{ 1 2 }
{ 1 -2 }
{ -1 2 }
{ -1 -2 }
{ 2 1 }
{ 2 -1 }
{ -2 1 }
{ -2 -1 }
```
[Answer]
# [R](https://www.r-project.org/), ~~42~~ ~~35~~ ~~34~~ 33 bytes
```
round(2*exp((1:2+0:7%/%2*pi)/2i))
```
[Try it online!](https://tio.run/##K/r/vyi/NC9Fw0grtaJAQ8PQykjbwMpcVV/VSKsgU1PfKFNT8/9/AA "R – Try It Online")
Outputs as complex numbers.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 9 bytes
```
12ẹ{ṅ|}ᵐp
```
[Try it online!](https://tio.run/##ASkA1v9icmFjaHlsb2cy/@KGsOKCgeG6ieKKpf8xMuG6uXvhuYV8feG1kHD//w "Brachylog – Try It Online")
[Generates](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/10753#10753) each move.
```
   {  }ᵐ     For each element of
  ẹ          the digits of
12           12,
     |       maybe
    ṅ        negate it.
        p    Output a permutation of the result.
```
Although `ᵐ` maps over digits if given a raw integer, it also smashes the results back into an integer, which doesn't play nice with signs.
[Answer]
# [R](https://www.r-project.org/), ~~37~~ ~~29~~ ~~26~~ 25 / 23\* bytes
*Edit: -1 byte thanks to pajonk*  
\**Edit 2: Or -2 more bytes [with output as elements of a 2x4 matrix](https://tio.run/##K/r/X8NQW8/UStdQyyRTUzVf1TAzTsPQykTz/38A), thanks to Giuseppe*
```
(1+.5:-1*4i)*1i^(2:9%/%2)
```
[Try it online!](https://tio.run/##K/r/X8NQW8/UStdQyyRTU8swM07DyMpSVV/VSPP/fwA "R – Try It Online")
Change of approach to try to compete with [pajonk](https://codegolf.stackexchange.com/a/247685/95126); now outputs as complex numbers.  
~~Still frustratingly 3 bytes longer than~~ ~~Now the same length as~~ Satisfyingly now shorter than a [hard-coded string](https://codegolf.stackexchange.com/a/247684/95126)...
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 9 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
2╤ç■gÉ±~¡
```
[Try it online.](https://tio.run/##AR0A4v9tYXRoZ29sZv//MuKVpMOn4pagZ8OJwrF@wqH//w)
**Explanation:**
```
2╤         # Push a list in the range [-2,2]: [-2,-1,0,1,2]
  ç        # Remove the 0 with a falsey filter
   ■       # Cartesian product with itself
    g      # Filter these pairs by,
     É     # using three characters as inner code-block:
      ±    #  Take the absolute values of the pair
       ~   #  Pop and push the values separated to the stack
        ¡  #  Check that they are NOT equal
           # (after which the entire stack is output implicitly as result)
```
[Answer]
# x86-64 machine code, 15 bytes
```
B8 01 02 FF FE AB 0F C8 AB C1 C8 18 73 F7 C3
```
[Try it online!](https://tio.run/##bVG7TsMwFJ3tr7gEVXL6khsqVDWEBdGNhQmpZHAdOzFK7ChOHxLi1wnXhTIgBvta53HPkSxnpZTDIHwD7DlidF7Wbidq0FSvSeMOoMRpCvy0edxseMIXtFsT3ztfULLzR9EGnl6QznXf@mRJyZuV0CGmehpHcUrpwZkCNJOV6ICNfbxN8gBfGyvrfaHgzveFcfPqnhrbQyOMZTF9p@Rs8NtVjoaUEs18HAZmsSA0kAFPcVxlsMI5mcSUkLZDTrNolBjA82qjKe4w@ZbnP49FSP/VvdonIStjFUhXqHUoTKSzvoe99aa0qoBzj3GLcexfJtbpH0jiksLBJQNGPHnBHjIbt9gyhWNlaoXbQnV@erjB0I9h@JS6FqUfZs3tEi/8mgz9qv4C "C (gcc) – Try It Online")
Writes a size-8 array of size-2 arrays of 8-bit integers to an address given in RDI.
In assembly:
```
f:  mov eax, 0xFEFF0201 # Set EAX to this value; -2, -1, 2, 1 from top to bottom.
r:  stosd       # Write EAX to the output address, advancing the pointer.
    bswap eax   # Reverse the order of the bytes of EAX, getting 1, 2, -1, -2.
    stosd       # Write EAX to the output address, advancing the pointer.
    ror eax, 24 # Rotate right by 24 bits, getting 2, -1, -2, 1.
    jnc r       # Jump back if CF (set from the last bit rotated: the high bit) is 0.
                #  This is true the first time.
                # After the jump, the value is added to the output again,
                #  then reversing gives 1, -2, -1, 2, which is also added to the output,
                # and then rotating gives -2, -1, 2, 1, and CF is 1, ending the loop.
    ret         # Return.
```
[Answer]
# [Nekomata](https://github.com/AlephAlpha/Nekomata), 3 bytes
```
į→ŋ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHHBgqWlJWm6FsuPrH_UNulo95LipORiqBhMDgA)
```
į→ŋ
į       [0,1] or [1,0]
 →      Increment
  ŋ     Optionally negate each element
```
---
## [Nekomata](https://github.com/AlephAlpha/Nekomata) before v0.3.5.0, 6 bytes
```
2R↕ᵐᶜ_
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHHBgqWlJWm6FmuMgh61TX24dcLDbXPilxQnJRdDJWAKAA)
A port of [@Unrelated String's](https://codegolf.stackexchange.com/users/85334/unrelated-string) [Brachylog](https://github.com/JCumin/Brachylog) [answer](https://codegolf.stackexchange.com/a/247700/9288).
```
2R          Range from 1 to 2
  ↕         Permutation
   ᵐᶜ_      Optionally negate each element
```
[Answer]
# [Regenerate](https://github.com/dloscutoff/Esolangs/tree/master/Regenerate) `a`, 13 bytes
```
-?1-?2|-?2-?1
```
Not sure if this is golfable unless more features are added to the language lol... but please prove me wrong!
Prints like this:
```
12
1-2
-12
-1-2
21
2-1
-21
-2-1
```
Breakdown:
```
-?1-?2|-?2-?1
              Print every string that is
-?1             -1 or 1
   -?2          followed by -2 or 2
      |       or
       -?2      -2 or 2
          -?1   followed by -1 or 1
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72qKDU9NS-1KLEkdVm0km6iUuyCpaUlaboWa3XtDXXtjWqAGMiCiEGlFkBpAA)
[Answer]
# [Python](https://www.python.org), 67 bytes
```
lambda:[z for i in range(99)if{*map(abs,z:=(i%5-2,i//5-2))}=={1,2}]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3nXMSc5NSEq2iqxTS8osUMhUy8xSKEvPSUzUsLTUz06q1chMLNBKTinWqrGw1MlVNdY10MvX1gZSmZq2tbbWhjlFtLMSo1QVFmXklGlppGpqaEJEFCyA0AA)
Shorter than using `itertools.product`
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~16~~ 13 bytes
```
»1rKȮ8»`-12`τ
```
[Try it online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLCuzFyS8iuOMK7YC0xMmDPhCIsIiIsIiJd)  
-3 thanks to [Steffan](https://codegolf.stackexchange.com/users/92689/steffan)  
**7 bytes**
(`o`, Port of [this](https://codegolf.stackexchange.com/a/247705/107262), also thanks to Steffan)
```
k-:dẊ…R
```
[Try it online!](https://vyxal.pythonanywhere.com/#WyJvIiwiIiwiay06ZOG6iuKAplIiLCIiLCIiXQ==)
### 16 bytes (old)
```
»-∞ðO∩ß¹¶"⊍»0\-¢
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLCuy3iiJ7DsE/iiKnDn8K5wrZcIuKKjcK7MFxcLcKiIiwiIiwiIl0=)
```
»-∞ðO∩ß¹¶"⊍»        # Compressed integer 201120201021102010201221
            0\-¢    # Replace 0 with -
```
  
Spent forever trying to find a cool answer but this is all my half asleep brain could come up with at the moment  
There is a 0% chance this is optimal :P
 
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 68 bytes
```
-[----->>+<+<]>-.>--..----.<.>.<.-..+..->.<.>.<.+.>.<.->.<.>.<.+>.<.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fN1oXBOzstG20bWLtdPXsdHX19EBCejZ6dkAM5GkDBeygXG2IIJwLIv7/BwA "brainfuck – Try It Online")
Start is Similar to Pyautogui's answer, with a loop running `255/5=51` times to set a starting cell to `51`. But I set two cells to `51`, and use one for the characters `12` and the other one (hunt and peck style) for the character `-`.
The output `211-2-21122-1-12-2-1-1-2` consists of alternating pairs of `2`s and `1`s with interspersed `-` where necessary. The first two `1`'s are read from the cell which generates the `-` as the value descends from `51` through `49` to `45`. The rest of the `1`s are from the same cell as the `2`.
# [brainfuck](https://github.com/TryItOnline/brainfuck), 29 bytes
```
+.+..-..>--..+..-..<.+.>+..<.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/q@NBKJ17UAUmLCxibX7r62nraenq6dnpwskIEwbIG2nDaL//wcA "brainfuck – Try It Online")
A different interpretation of the rules outputting binary values `-2, -1, 1, 2` when run on a blank Brainfuck tape. For convenient verification the header initializes the two cells used on the tape to `48 = ASCII '0'` so that the outputs for `-2, -1, 1, 2` are `. / 1 2` respectively.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/language/), ~~41~~ 36 bytes
-5 bytes, thanks @att.
Selects the elements with odd element sum from the group of all length 2 tuples with elements from the set {1,-2,2,-2}:
```
{1,-1,2,-2}~Tuples~2~Select~OddQ@*Tr
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~74~~ 70 bytes
*-4 bytes thanks to [@ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)*
```
i;main(){for(;i<32;++i)putchar(i&1?(i/2^i/8)%2+49:i&4+6*(i&2)?45:43);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/TOjcxM09Dszotv0jDOtPG2MhaWztTs6C0JDkjsUgjU83QXiNT3yguU99CU9VI28TSKlPNRNtMCyhjpGlvYmplYqxpXfv/PwA "C (gcc) – Try It Online")
Edit: it's obviosly longer than necessary, but it's the shortest way I found without printing directly the result.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 68 bytes
```
y;main(x){for(y=3;x--<-3?x=--y+6:x*x+y*y-5||printf("%d,%d;",x,y););}
```
[Try it online!](https://tio.run/##BcHhCkAwEADgd1Fqs92vxQ9HnmVNk2KEcpd5def7AkwhiDCufk6K9BO3Q3HvkAA6cAP1AGyalioyXDHUOe/HnK6oinK05YiFJcsaNb4iX4iLn06B@wc "C (gcc) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 16 bytes
```
ＩΦＥφ⁻↨ι⁵⁰χ⁼⁵ΣＸι²
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwy0zpyS1SMM3sUDD0MDAQEfBNzOvtFjDKbE4VSNTR8HUQFNHwRBEuBaWJuYUa5jqKASX5moE5JcDdQEVGGmCgfX///91y3IA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
   φ                Predefined variable `1000`
  Ｅ                 Map over implicit range
      ι             Current value
     ↨              Convert to base (i.e. divmod)
       ⁵⁰           Literal integer `50`
    ⁻               Vectorised subtract
         χ          Predefined variable `10`
 Φ                  Filtered where
              ι     Current pair
             Ｘ      Vectorised raised to power
               ²    Literal integer `2`
            Σ       Take the sum
          ⁼         Is equal to
           ⁵        Literal integer `5`
Ｉ                   Cast to string
                    Implicitly print
```
Using base conversion results in the invalid "pairs" `[]`, `[-9]`, `[-8]`, ... `[39]` but none of them have a Euclidean distance of `√5`. Boring string compression version for 11 bytes:
```
”{“↥?UV&✳¿>
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvREPJSNfQ0EgXSOoaGRpCaF1DIyNDJU3r////65blAAA "Charcoal – Try It Online") Link is to verbose version of code.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 33 bytes
```
x,y=1,2
4.times{p x,t=y,y=-x,x=t}
```
[Try it online!](https://tio.run/##KypNqvz/v0Kn0tZQx4jLRK8kMze1uLpAoUKnxLYSKKpboVNhW1L7/z8A "Ruby – Try It Online")
A straightforward rotation based on a concept of `y,x=-x,y` with some extra code to print in reverse as well.
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 18 bytes
```
{1-1}{2-2}cpJ)<-_+
```
[Try it online!](https://tio.run/##SyotykktLixN/f@/2lDXsLbaSNeoNrnAS9NGN177f@B/AA "Burlesque – Try It Online")
```
{1-1} # {1 -1}
{2-2} # {2 -2}
cp    # Cart product
J     # Duplicate
)<-   # Reverse each in dup
_+    # Concat
```
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 19 bytes
```
(2|+´)¨⊸/⥊⋈⌜˜-⊸∾1‿2
```
[Try it at BQN online](https://mlochbaum.github.io/BQN/try.html#code=KDJ8K8K0KcKo4oq4L+KliuKLiOKMnMucLeKKuOKIvjHigL8y)
### Explanation
```
(2|+´)¨⊸/⥊⋈⌜˜-⊸∾1‿2
                  1‿2  List containing 1 and 2
                 ∾     Prepend
               -⊸      its negation
           ⋈⌜˜         Table of each item of that list paired with each item of that list
         ⥊             Deshape into a list of two-element lists
(    )¨                For each of those:
   +´                    Get its sum
 2|                      Mod 2
       ⊸/              Select the elements for which that result is 1
```
[Answer]
# Excel, ~~49~~ 40 bytes
Saved 9 bytes thanks to [JvdV](https://codegolf.stackexchange.com/questions/247676/generate-all-8-knights-moves/247724?noredirect=1#comment560567_247724)
```
=CONCAT({1,-1}&2*{1;-1},2*{1,-1}&{1;-1})
```
Outputs pairs without delimeters.
[![Screenshot](https://i.stack.imgur.com/yeiQk.png)](https://i.stack.imgur.com/yeiQk.png)
---
# Excel, 27 bytes
```
="12-121-2-1-221-212-1-2-1"
```
... but that's too boring.
[Answer]
A reference for all the trivial approaches.
# [Python](https://www.python.org), 33 bytes
```
print('2-112-2-1-211-2-1-2-1221')
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3FQuKMvNKNNSNdA0NjXSBpK6RoSGE1jU0MjJU14QohKqH6QMA)
# [R](https://www.r-project.org/), 26 bytes
```
'2-112-2-1-211-2-1-2-1221'
```
[Try it online!](https://tio.run/##K/r/X91I19DQSBdI6hoZGkJoXUMjI0P1//8B "R – Try It Online")
# [Wolfram Language (Mathematica)](https://www.wolfram.com/language/), 26 bytes
Assumes a notebook environment. If this is false `Echo@` can be added in front at the cost of 5 bytes.
```
"2-112-2-1-211-2-1-2-1221"
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78/981OSPfQclI19DQSBdI6hoZGkJoXUMjI0Ol//8B "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [A0A0](https://esolangs.org/wiki/A0A0), 39 bytes
```
O-1212212
O-1
O-2
O-11
O-2
O-1
O-2
O-21
```
Prints `-1212212-1-2-11-2-1-2-21`. This simply prints many negative numbers, of which the negative numbers form non-separated pairs of relative positions. Since there are eight negative numbers, we use eight different output instructions.
[Answer]
# JavaScript, 58 bytes
```
_=>[...'01234567'].map(i=>[((i&4)-2)/(m=i%2+1),(i&2)*m-m])
```
[Try it online!](https://tio.run/##DchbDkAwEADA02AXXdTrqy4iIo1XKq2KiutX53NO@Um3POp@2WXXze/Cz2IYiSgpK143bdcnExl5gwoNoOIGGccCjFARzyrMQ3FMDTMT@sVezuqNtD1gB0T/Aw "JavaScript (Node.js) – Try It Online")
I know it's shorter to hardcode, but that feels cheaty...
[Answer]
# [(8-bit, wrapping) Brainfuck](https://github.com/TryItOnline/brainfuck), 80 bytes
```
-[>+<-----]>-.[->+>+<<]>>-----.<-..+.>.<.>.<-.>.<+.-..>.<+.>.<-.>.<+.>.<-.+..-.>
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70yqSgxMy-tNDl7wYKlpSVpuhY3A3Sj7bRtdEEg1k5XL1rXThvIt4m1swOL6dno6ulp69np2YCwLojQ1gMKgWmECJilrQeUsYOYCzUeZg0A)
Outputs in the example format: "2-112-2-1-211-2-1-2-1221".
Originally, this was in severe need of a golf, having been made by an [automated tool](https://copy.sh/brainfuck/text.html). I have now optimized it a little. It now uses a similar technique to [Level River St's answer](https://codegolf.stackexchange.com/a/247722/104836), though I arrived at it independently, and it differs in the details; instead of 51, the starting value is 50.
[Answer]
# [Headascii](https://esolangs.org/wiki/Headass#Headascii), 71 bytes
```
++++[]+^^^D^^^D^P]PD^P]+PD^P]+PD^P]PD^P]P+PPD^P]PPD^P]+PD^P]+P-PP+PP-P!
```
Outputs `-1-2-2-1-122-11-2-211221`
Try it [Here](https://replit.com/@thejonymyster/HA23) by executing
```
erun("++++[]+^^^D^^^D^P]PD^P]+PD^P]+PD^P]PD^P]P+PPD^P]PPD^P]+PD^P]+P-PP+PP-P!")
```
I'm ashamed at how long this is. I have to make a golfier language.............................
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
X®‚xâ˜Â«
```
[Try it online!](https://tio.run/##ARkA5v9vc2FiaWX//1jCruKAmnjDosucw4LCq/// "05AB1E – Try It Online")
```
X     push an integer variable, which is initialized to 1 (using 1 makes it a string, which makes the output look weird)
®     push the register, which is initialized to -1
‚     pair, to get [1, -1]
x     push tos and itself doubled, to get [1, -1], [2, -2]
â     Cartesian product, all pairs
˜     Flatten, to get a list of coordinates instead of a list of pairs
Â     Push tos and itself reversed
«     Concatenate
```
]