[Question]
  [
# Your task
In your language of choice: create a program that outputs `1`
This `1` may either be a string or value equivalent to the number one.
# The shifting catch
If you take the **unicode codepoint** (or whatever codepoint encoding your languages uses if not UTF) for each character in your program, and shift each of those values by the **same non-zero amount**, then the result will be another program (potentially executable in different language) that also outputs `1`.
**Find the unicode codepoint of a character:** [here](https://www.fileformat.info/info/unicode/char/search.htm).
**E.g;**
If your program looked like: `X?$A`, and somehow output `1`, and it also miraculously outputs `1` after shifting all of it's Unicode indices up by, say, 10; then that process of shifting looks like this:
```
original program: X?$A
letter    codepoint  shift   new-codepoint   new-letter
X            88       +10        98          b   
 ?           63                  73          I
  $          36                  46          .
   A         65                  75          K
new program: BI.K
```
**Note:** The Unicode codepoint will often be represented in the form similar to `U+0058`. `58` is the **hexadecimal** codepoint . In **decimal**, that's `88`. The link above will list `88` under the `UTF (decimal)` encoding section. That is the number you want to increment or decrement!
# Examples of valid outputs
```
1
"1"
'1'
[1]
(1)
1.0
00000001
one
```
**Note:** If your language only supports the output of `true` as an equivalent to `1`, that is acceptable. Exit-codes are also valid outputs.
# Scoring
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so **lowest bytes wins**!
* Brownie points for creativity & if the two programs are in separate languages.
  
[Answer]
# Java, 62 bytes
```
interface M{static void main(String[]a){System.out.print(1);}}
```
[Try it online.](https://tio.run/##y0osS9TNSsn@/z8zryS1KC0xOVXBt7q4JLEkM1mhLD8zRSE3MTNPI7ikKDMvPTo2UbM6uLK4JDVXL7@0RK8AKFiiYahpXVv7/z8A)
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 62 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
\agXeYTVXŒπ@nfgTg\VŒπib\WŒπ`T\a‚ÇÇFge\aZNPT‚ÇÉnFlfgX`!bhg!ce\ag‚ÇÇ$‚ÇÉ.pp
```
Uses the 05AB1E encoding, with the codepoints all decreased by 13:
* `interface M{static void main(String[]a){System.out.print(1);}}` has the codepoints `[105,110,116,101,114,102,97,99,101,32,77,123,115,116,97,116,105,99,32,118,111,105,100,32,109,97,105,110,40,83,116,114,105,110,103,91,93,97,41,123,83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,40,49,41,59,125,125]`
* `\agXeYTVXŒπ@nfgTg\VŒπib\WŒπ`T\a‚ÇÇFge\aZNPT‚ÇÉnFlfgX`!bhg!ce\ag‚ÇÇ$‚ÇÉ.pp` has the codepoints `[92,97,103,88,101,89,84,86,88,19,64,110,102,103,84,103,92,86,19,105,98,92,87,19,96,84,92,97,27,70,103,101,92,97,90,78,80,84,28,110,70,108,102,103,88,96,33,98,104,103,33,99,101,92,97,103,27,36,28,46,112,112]`.
[Try it online.](https://tio.run/##yy9OTMpM/f8/JjE9IjUyJCzi3E6HvLT0kPSYsHM7M5Niws/tTAiJSXzU1OSWnhqTGOUXEPKoqTnPLSctPSJBMSkjXTEZKJwOlFcBiusVFPz/DwA)
### Explanation:
**Java:**
```
interface M{                   // Full program:
  static void main(String[]a){ //  Mandatory main-method:
    System.out.print(          //   Print without trailing newline:
      1);}}                    //    Print 1
```
**05AB1E:**
```
\                  # Discard the top of the stack (no-op, since it's already empty)
                   #  STACK: []
 a                 # Check if it only consists of letters (resulting in falsey/0
                   # for an empty string "", which is used implicitly without input)
                   #  STACK: [0]
  g                # Push and push its length, which is 1
                   #  STACK: [1]
   X               # Push variable `X`, which is 1 by default
                   #  STACK: [1,1]
    e              # Push the number of permutations n!/(n-r)! with both 1s, which is 1
                   #  STACK: [1]
     Y             # Push variable `Y`, which is 2 by default
                   #  STACK: [1,2]
      T            # Push builtin 10
                   #  STACK: [1,2,10]
       V           # Pop and store it in variable `Y`
                   #  STACK: [1,2]
        X          # Push variable `X` again, which is 1 by default
                   #  STACK: [1,2,1]
         Œπ         # Uninterleave using the 2 and 1, resulting in ["2"]
                   #  STACK: [1,["2"]]
          @        # Check whether 1 is >= ["2"], resulting in [0]
                   #  STACK: [[0]]
           n       # Square it
                   #  STACK: [[0]]
            f      # Get a list of all prime factors (none for 0), which results in []
                   #  STACK: [[[]]]
             g     # Pop and push its length
                   #  STACK: [1]
              T    # Push builtin 10
                   #  STACK: [1,10]
               g   # Pop and push its length
                   #  STACK: [1,2]
                \  # Discard it
                   #  STACK: [1]
                 V # Pop and store it in variable `Y`
                   #  STACK: []
```
From here on out I can't really explain it anymore, since it does things I wasn't expecting:
```
Œπ                  # Uninterleave (would take either one or two arguments, but since the
                   # stack is empty, it somehow remembered the 1 that was previously on
                   # the stack and results in ["1"] - 
                   # A program `Œπ` without input would result in an error instead..)
                   #  STACK: [["1"]]
 i                 # If-statement, which will be entered if the top is 1;
                   # since it's ["1"] instead of 1, it won't enter
                   #  STACK: []
  b\WŒπ`T\a‚ÇÇFge\aZNPT‚ÇÉnFlfgX`!bhg!ce\ag‚ÇÇ$‚ÇÉ.pp
                   #  No-ops within the if-statement
                   # It again somehow remembers the previous ["1"] that was on the stack,
                   # which is output implicitly as result
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 3 bytes
```
1*1
```
(Works in Japt too.)
[Try it online!](https://tio.run/##yy9OTMpM/f/fUMvw/38A "05AB1E ‚Äì Try It Online") 
# [Japt](https://github.com/ETHproductions/japt), 3 bytes
```
6/6
```
[Try it online!](https://tio.run/##y0osKPn/30zf7P9/AA "Japt ‚Äì Try It Online")
Derived from the 05AB1E program by shifting by 5 *Unicode* codepoints.
The Japt program performs division, but don't be fooled into thinking that the 05AB1E program is performing multiplication. The `*` (square) operator acts only on the first `1`; the output is actually just an implicit print of the second `1`.
The same idea works with the 05AB1E/Japt program pairs `1-1` and `3/3` (shift 2) and `1+1` and `5/5` (shift 4).
[Answer]
# Python 3, ~~19~~ 17 bytes
**-2 bytes thanks to Jonathan Allan**
```
#]pal )!‚êõ
exit(1)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Xzm2IDFHQVNRmiu1IrNEw1Dz/38A "Python 3 ‚Äì Try It Online")
## Shifted +8
```
+exit(1)#‚êím‚ê£q|091
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Xzu1IrNEw1BTWSj3UENhjYGl4f//AA "Python 3 ‚Äì Try It Online")
where ‚êõ, ‚êí and ‚ê£ are literal `\x1b`, `\x12` and `\x80` bytes respectively.
Not much by the way of trickery going on here except prepending the print in the shift version with a `+` so that when we shift it the first character of the second program to the `#` character it doesn't send any characters into a negative codepoint (if we naiÃàvely shifted `e` back to `#`, `(` would be sent to `\x-` which doesn't exist). Outputs by exit code.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 2x 1 [byte](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
Without an input, any of these single characters will output `1`, so just pick two you like. :)
* `1` (self explanatory): [Try it online.](https://tio.run/##yy9OTMpM/f/f8P9/AA)
* `X` (variable, which is 1 by default): [Try it online.](https://tio.run/##yy9OTMpM/f8/4v9/AA)
* `‚â†` (`!= 1` check; without input it will do `"" != 1`, resulting in truthy/1): [Try it online.](https://tio.run/##yy9OTMpM/f//UeeC//8B)
* `@` (`>=` check; without input it will do `"" >= ""`, resulting in truthy/1): [Try it online.](https://tio.run/##yy9OTMpM/f/f4f9/AA)
* `Q` (`==` check; without input it will do `"" == ""`, resulting in truthy/1): [Try it online.](https://tio.run/##yy9OTMpM/f8/8P9/AA)
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 2x2 bytes
```
*0
+1
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97b@WAZe2IYj5P43rUd/UUOdgBXUtbQNDdQA "APL (Dyalog Unicode) ‚Äì Try It Online")
`*0` computes `e^0`, and `+1` computes complex conjugate of 1. `*0` has Unicode codepoint 42 and 48, and `+1` has 43 and 49, so the two are different by exactly one.
Also works in many different flavors of APL, including... (copied from [Ad√°m's APL bounty](https://codegolf.meta.stackexchange.com/a/17363/78410))
> 
> [Dyalog APL](https://www.dyalog.com/) Classic/Unicode/[Extended](https://github.com/abrudz/dyalog-apl-extended)/[Prime](https://github.com/abrudz/dyalog-apl-prime), [APL2](https://www.ibm.com/uk-en/marketplace/apl2/details), [APL+](http://apl2000.com/), [APLSE](https://play.google.com/store/apps/details?id=org.gemesys.android.aplse), [GNU/APL](https://www.gnu.org/software/apl/), [Sharp APL](http://www.sigapl.org/Archives/waterloo_archive/apl/sharp.apl/index.html), [sAPL](https://play.google.com/store/apps/details?id=org.gemesys.android.sapl), [SAX](https://github.com/tobia/luit-sax), [NARS](http://www.nars2000.org/), [APLX](https://www.dyalog.com/aplx.htm), [A+](http://www.aplusdev.org/index.html), [dzaima/APL](https://github.com/dzaima/apl), [ngn/APL](https://gitlab.com/n9n/apl), [APL\iv](https://github.com/ktye/iv), [Watcom APL](https://play.google.com/store/apps/details?id=org.gemesys.android.watapl), or [APL\360](http://wotho.ethz.ch/mvt4apl-2.00/).
> 
> 
> 
... which makes this a polyglot of at least 19 languages!
[Answer]
# Unary, 84 bytes
```
000000000000000000000000000000000000000000000000000000000000000000000000000000000000
```
Outputs the character with codepoint 1 (equivalent brainfuck: `+.`). Since Unary cares only about the length of the program, a shift of any number will not change the output. 
[Answer]
# HTML, 8 bytes
```
<ol><li>
```
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
!TQ#!QN#
```
[Try it online!](https://tio.run/##yy9OTMpM/f9fMSRQWTHQT/n/fwA "05AB1E ‚Äì Try It Online")
---
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
([X*(XU*
```
[Try it online!](https://tio.run/##y0rNyan8/18jOkJLIyJU6/9/AA "Jelly ‚Äì Try It Online")
---
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
5he75eb7
```
[Try it online!](https://tio.run/##y0rNyan8/980I9XcNDXJ/P9/AA "Jelly ‚Äì Try It Online")
---
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
;nk=;kh=
```
[Try it online!](https://tio.run/##y0rNyan8/986L9vWOjvD9v9/AA "Jelly ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
@spB@pmB
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fobjAyaEg1@n/fwA "05AB1E ‚Äì Try It Online")
---
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
H{xJHxuJ
```
[Try it online!](https://tio.run/##y0rNyan8/9@jusLLo6LU6/9/AA "Jelly ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
Outputs `["1"]`.
```
Q„ÅSQÅ~S
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/8FDLocbgwEONdcH//wMA "05AB1E ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
V‰†XV†ƒX
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/7FDnobaIsENth5oj/v8HAA "05AB1E ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
X‹ˆZXˆ…Z
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/4lD3oY6oiEMdh1qj/v8HAA "05AB1E ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
]êç_]çŠ_
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/9tCEQ73xsYd6D3XF//8PAA "05AB1E ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
a”‘ca‘Žc
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/8dCUQxOTEw9NPNSX/P8/AA "05AB1E ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
e˜•ge•’g
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/9dCMQ1PTUw9NPTQp/f9/AA "05AB1E ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
kž›mk›˜m
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/@9C8Q7Nzsw/NPjQj9/9/AA "05AB1E ‚Äì Try It Online")
---
("Pffffft! Of *course* I know how 05AB1E and Jelly work! I *totally* didn't just brute-force a bunch of combinations on TIO. That would be [crazy](https://tio.run/##LYyxCsMgFEX3fMUjkyJ5QylZqkLJJziWDGKT9BXjC0b6@8ahFw5nOHC//ufPkOkoQ@L3UqszveZodSTbdytnQWBguI8PINAw3pqVkh20BU4nxwUjb8KVTGnDNfM@fXye2pdAxFfDzbj7QwRjA4Z/exYhFUkpa70A)! It would *never* work!")
[Answer]
# CSS, 48 bytes
```
body:after{content:"1"}z|ancx9`esdqzbnmsdms9!0!|
```
```
cpez;bgufs|dpoufou;#2#~{}body:after{content:"1"}
```
[Answer]
# [!@#$%^&\*()\_+](https://github.com/ConorOBrien-Foxx/ecndpcaalrlp), 4 bytes
```
1@/>
```
[Try it online!](https://tio.run/##S03OSylITkzMKcop@P/f0EHf7v9/AA "!@#$%^&*()_+ ‚Äì Try It Online")
## Explanation
```
1    # Pushes 1
 @   # Prints top of the stack (1)
  /> # Pushes some meaningless stuff
```
# Shifted +2
```
3B1@
```
[Try it online!](https://tio.run/##S03OSylITkzMKcop@P/f2MnQ4f9/AA "!@#$%^&*()_+ ‚Äì Try It Online")
## Explanation
```
3B   # Pushes some meaningless stuff
  1  # Pushes 1
   @ # Prints top of the stack (1)
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 2 bytes
```
s1
```
[Try it online!](https://tio.run/##K6gsyfj/v9jw/38A "Pyth ‚Äì Try It Online")
# [Pyth](https://github.com/isaacg1/pyth), 2 bytes, Shifted +1
```
t2
```
[Try it online!](https://tio.run/##K6gsyfj/v8To/38A "Pyth ‚Äì Try It Online")
---
First Program translates to `floor(1)`  
Second Program translates to `2 - 1`
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), 2 x 18 bytes
```
" " " ‚êã ‚êå
‚êã   ‚êå
" ‚êã 
```
[Try it online.](https://tio.run/##K8/ILEktLkhMTv3/X0kBBLk5ebhAGMT6/x8A).
All codepoints decreased by 2 will result in:
```
 ‚êü ‚êü ‚êü  ‚êá
‚êà   ‚êá
‚êà ‚êü ‚êá
```
[Try it online.](https://tio.run/##K8/ILEktLkhMTv3/X0EOBDnZuThAGMT6/x8A)
Both programs contain unprintables. The first program contains characters with the codepoints: `[34,32,34,32,34,32,11,9,12,10,11,9,12,10,34,32,11,9]`. The second program with codepoints: `[32,30,32,30,32,30,9,7,10,8,9,7,10,8,32,30,9,7]`. In Whitespace, all characters except for spaces (codepoint 32), tabs (codepoint 9), and newlines (codepoint 10) are ignored, so both programs are actually the following:
```
SSSTN
TN
ST
```
Where `S`, `T`, and `N` are spaces, tabs, and newlines respectively.
This program will:
* `SSSTN`: Push 1
* `TNST`: Print it as integer to STDOUT
It's actually possible to create 3 x 27 bytes, 4 x 36 bytes, and even 5 x 45 bytes programs by having the codepoints apart by 2, still resulting in the same basic program above after all non-whitespace characters are ignored.
[Answer]
# J, ~~3~~ 2 bytes
```
=0
```
Monadic `=` means self-classify. It compares each item with each other item to see if it's the same. 0 is 0. It returns 1.
# Shifted +1
```
>1
```
Unboxes 1, which does nothing, because it wasn't in a box in the first place.
## Alternate 2-byters:
`!1` (1 factorial) shifted by 2 is `#3` (amount of items in 3)
`!0` (0 factorial) shifted by 2 is `#2` (amount of items in 2) shifted by 7 is `*9` (sign of 9)
[Answer]
# JavaScript (web), 19 bytes
## Form #1
```
`kdqs_0_:`;alert`1`
```
## Form #2 (#1 shifted by +1)
```
alert`1`;a<bmfsua2a
```
This took me longer than what I'd like to admit, but it was a fun challenge. üòÅ
Form #2 throws a `ReferenceError`, but [that seems to be allowed](https://codegolf.meta.stackexchange.com/a/4781/95061).
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 3 bytes
Outputs the character with the codepoint 1. [This is allowed by default.](https://codegolf.meta.stackexchange.com/a/18027/92069)
```
(+.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fQ1vv/38A "brainfuck ‚Äì Try It Online")
# Shifted +3
```
+.1
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fW8/w/38A "brainfuck ‚Äì Try It Online")
## Explanation
The `+` character increments the current item of the tape, and `.` outputs that value as a character. All other characters are ignored.
[Answer]
# Polyglot, 3 bytes
Shift of 2. Works in R, Octave, Japt, and probably others.
```
1+0
3-2
```
[Try it online (Octave)](https://tio.run/##y08uSSxL/f/fUNuAy1jX6P9/AA "Octave ‚Äì Try It Online")
[Try it online (R)](https://tio.run/##K/r/31DbgMtY1@j/fwA "R ‚Äì Try It Online")
[Try it online (Japt)](https://tio.run/##y0osKPn/31jX6P9/AA "Japt ‚Äì Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 1 [byte](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Among many others:
```
1
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=MQ)
```
√Ñ
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=xA)
```
l
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=bA)
[Answer]
# [R](https://www.r-project.org/), 4 bytes
```
\061\043\030\077
```
(octal bytes, equivalent to: `'1' '#' CAN '?'`)
Shifted -14:
```
\043\025\012\061
```
(octal bytes, equivalent to `'#' NAK LF '1'`)
Unshifted program consists of number 1 (which is outputted unchanged), followed by `#` (comment character) and 'comments' of CAN (ASCII code \030) and '?'. 
Shifted +14 program consists of `#` (comment character) and 'comment' of NAK (ASCII code \025), followed by a new line. On the next line is the number 1 (which is outputted unchanged). 
Test at bash command-line using `echo` (or `gecho`):
```
echo -e '\061\043\030\077' >prog1.r
echo -e '\043\025\012\061' >prog2.r
Rscript prog1.r
# [1] 1
Rscript prog2.r
# [1] 1
```
[Answer]
# [naz](https://github.com/sporeball/naz), 4 bytes
```
1a1o
```
**Explanation**
```
1a # Add 1 to the register
1o # Output once
```
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 4 bytes
```
2b2p
```
A shift of 1 Unicode codepoint forward from the original.
**Explanation**
```
2    # Push 2
 b   # Convert to binary
  2  # Push 2
   p # Push isPrime(2)
# ...after which the result is output implicitly
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1 [byte](https://github.com/DennisMitchell/jelly/wiki/Code-page)
`¬¨` (logical NOT) vs `‚Äò` (increment)
**[Try `¬¨` online!](https://tio.run/##y0rNyan8///Qmv//AQ "Jelly ‚Äì Try It Online")** or **[Try `‚Äò` online!](https://tio.run/##y0rNyan8//9Rw4z//wE "Jelly ‚Äì Try It Online")**
This works because given no input a Jelly program has a default argument of `0`.
There are \$\binom{21}{2}=210\$ different pairs of single-byte programs to choose from since there are \$21\$ single bytes on Jelly's [code-page](https://github.com/DennisMitchell/jelly/wiki/Code-page) which yield `1` with no input:
[Answer]
# [Io](http://iolanguage.org/), 6 bytes
```
1print
```
[Try it online!](https://tio.run/##y8z//9@woCgzr@T/fwA "Io ‚Äì Try It Online")
# [Commentator](https://github.com/cairdcoinheringaahing/Commentator), (Shifted -17)
```
 _aX]c
```
[Try it online!](https://tio.run/##S87PzU3NK0ksyS/6/18hPjEiNvn/fwA "Commentator ‚Äì Try It Online")
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), 1 byte (SBCS)
```
1
```
[Try it online!](https://tio.run/##y05N///f8P9/AA "Keg ‚Äì Try It Online")
Implicitly outputs 1
## Shifted +198
```
üÑÇ
```
[Try it online!](https://tio.run/##y05N////w/yWpv//AQ "Keg ‚Äì Try It Online")
Uses the push'n'print to print 1
[Answer]
## Batch, ~~27~~ 17 bytes
```
:_]biÔøΩ+ÔøΩ4
@echo 1
```
The `:` introduces a label of unprintables, so the line is ignored, and the second line prints `1`. Shifted by 6:
```
@echo 1
:ÔøΩFkinu&7
```
Much the same, except this time the second line is ignored.
Unfortunately I've mangled the unprintables. Sorry about that. Feel free to fix it.
[Answer]
# [;#+](https://github.com/ConorOBrien-Foxx/shp), 4 bytes
```
9n;p
```
[Try it online!](https://tio.run/##K84o@P/fMs8aSAIA ";#+ ‚Äì Try It Online")
# [;#+](https://github.com/ConorOBrien-Foxx/shp), 4 bytes, Shift +2
```
;p=r
```
[Try it online!](https://tio.run/##K84o@P/fusC26P9/AA ";#+ ‚Äì Try It Online")
---
## Explanation
`;` - increments the counter  
`p` - outputs the counter as a number
`9`, `n`, `=` and `r` are not commands in [;#+](https://github.com/ConorOBrien-Foxx/shp) so they can be ignored.
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 6 bytes
```
i1<esc><nul>h0
```
* Original: [Try it online!](https://tio.run/##K/v/P9NQmiHD4P9/AA "V (vim) ‚Äì Try It Online")
* Shifted: [Try it online!](https://tio.run/##K/v/P8tIhjHT8P9/AA "V (vim) ‚Äì Try It Online")
[Answer]
# bc (?), 3 bytes
```
1+0
```
Shift 2:
```
3-2
```
Use as `echo 1+0 | bc` in bash.
[Answer]
# `pdfTeX -halt-on-error`, 1 byte
```
_
```
and
```
^
```
Both versions will throw an error as `_` and `^` are only allowed in math-mode. Will return a 1 as exit code (due to the error).
[Answer]
# [Perl 5](https://www.perl.org/) -p, 8 bytes + 1 byte/keypress input = 9 bytes
*Edit: -2 bytes and much nicer printable programs thanks to Dom Hastings*
Each program requires input of 1 byte, or a single carriage-return keypress.
I've counted this as +1 byte, but I'm not terribly sure how valid this is... 
```
$_++#^**
```
[Try it online!](https://tio.run/##K0gtyjH9/18lXltbOU5L6///RK5/@QUlmfl5xf91CwA "Perl 5 ‚Äì Try It Online")
Shifted +1:
```
%`,,$_++
```
[Try it online!](https://tio.run/##K0gtyjH9/181QUdHJV5b@///JK5/@QUlmfl5xf91CwA "Perl 5 ‚Äì Try It Online")
One might (validly) argue that since the extra input/keypress is part of the byte-count, it should also be shifted along with the codepoints of the program. Fortunately, there are inputs for which this works Ok:
```
echo 'a' | perl -pe '$_++#^**'
# 1
echo 'b' | perl -pe '%`,,$_++'
# 1
```
[Answer]
**JavaScript, 3**
`3-2` becomes `2,1` shifted by -1.  
`1+0` becomes `2,1` shifted by +1. 
Which is cool because `1+0` shifted by one becomes `2,1` shifted by one becomes `3-2` all three produce 1
---
```
let code = '1+0';
console.log (code, eval(code));
code = code.split('').map(c => String.fromCharCode(c.charCodeAt(0) + 1)).join('');
console.log (code, eval(code));
code = code.split('').map(c => String.fromCharCode(c.charCodeAt(0) + 1)).join('');
console.log (code, eval(code));
```
[Answer]
# [CJam](https://esolangs.org/wiki/CJam), 1 byte
```
1
```
```
X
```
For whatever reason, CJam has `X` as a builtin for 1, and since it outputs implicitly, you can just use those two. However, I thought it'd be more interesting to find a 2-byte solution.
```
XR
```
[Try it online!](https://tio.run/##S85KzP3/PyLo/38A "CJam ‚Äì Try It Online")
Offset by +38:
```
2,
```
[Try it online!](https://tio.run/##S85KzP3/30jn/38A "CJam ‚Äì Try It Online")
Explanations:
```
X    Push 1 to the stack
 R   Push an empty array to the stack
     (implicit) Output the stack
```
```
2    Push 2 to the stack
 ,   Pop and push range from 0 to 1 less than the popped number
     (implicit) Output the stack
```
Note that this is not only my first time golfing, but also my first time coding a program (well, programs) in CJam, so let me know how I did!
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 5 bytes
```
=-1!@
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/99W11DR4f9/AA "Hexagony ‚Äì Try It Online")
# [Hexagony](https://github.com/m-ender/hexagony), 5 bytes, Shifted -12
```
1!%4
```
**Hexdump:**
```
00000000  31 21 25 15 34     |1!%.4|
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/99QUVXU5P9/AA "Hexagony ‚Äì Try It Online")
# Explanation
Because of the small size and lack of mirrors, the programs are mostly executed linearly.
### Non-shifted Program
```
=       Reverse direction of memory pointer
 -      Sets the current memory edge to the difference of the left and right neighbors (0 - 0 = 0)
  1     Multiply current memory edge by 10 then add 1 (0 * 10 + 1 = 1)
   !    Outputs the value of current memory edge to stdout as an integer
    @   Terminate the program
```
### Shifted Program
```
1       Multiply current memory edge by 10 then add 1 (0 * 10 + 1 = 1)
 !      Outputs the value of current memory edge to stdout as an integer
  %     Sets the current memory edge to the modulo of the left and right neighbours
        (1 % 0) causes program to exit because of division by 0
    4   Does not matter since the program as already exited
```
]