Code Golf

#5: Post edited by

trichoplax‭ · 2022-11-12T13:24:47Z (over 1 year ago)
Mark as finalized

Copy Link

Raw

Markdown

~~Encode with ROT13.5~~

Encode with ROT13.5 [FINALIZED]

Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").
## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters
## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
- For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
- A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
- An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
- A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
- Any other character will remain unchanged
## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):
```text
:
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```
## Test cases
Test cases are in the format `"input string" : "output string"`.
```text
"gnat irk terra" : "tang vex green"
"2468" : "7913"
"#%&@,.:;?" : "#%&@,.:;?"
"Rot13.5 & Ebg68.0" : "Ebg68.0 & Rot13.5"
```
> Explanations are optional, but I'm more likely to upvote answers that have one.

# Now posted: [Encode with ROT13.5](https://codegolf.codidact.com/posts/287381)
---
Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").
## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters
## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
- For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
- A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
- An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
- A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
- Any other character will remain unchanged
## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):
```text
:
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```
## Test cases
Test cases are in the format `"input string" : "output string"`.
```text
"gnat irk terra" : "tang vex green"
"2468" : "7913"
"#%&@,.:;?" : "#%&@,.:;?"
"Rot13.5 & Ebg68.0" : "Ebg68.0 & Rot13.5"
```
> Explanations are optional, but I'm more likely to upvote answers that have one.

code-golf string encoding

code-golf string finalized encoding

#4: Post edited by

trichoplax‭ · 2022-11-11T17:20:55Z (over 1 year ago)
Add hope for explanations

Copy Link

Raw

Markdown

Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").
## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters
## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
- For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
- A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
- An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
- A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
- Any other character will remain unchanged
## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):
```text
:
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```
## Test cases
Test cases are in the format `"input string" : "output string"`.
```text
"gnat irk terra" : "tang vex green"
"2468" : "7913"
"#%&@,.:;?" : "#%&@,.:;?"
"Rot13.5 & Ebg68.0" : "Ebg68.0 & Rot13.5"
~~```~~

Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").
## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters
## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
- For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
- A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
- An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
- A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
- Any other character will remain unchanged
## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):
```text
:
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```
## Test cases
Test cases are in the format `"input string" : "output string"`.
```text
"gnat irk terra" : "tang vex green"
"2468" : "7913"
"#%&@,.:;?" : "#%&@,.:;?"
"Rot13.5 & Ebg68.0" : "Ebg68.0 & Rot13.5"
```
> Explanations are optional, but I'm more likely to upvote answers that have one.

#3: Post edited by

trichoplax‭ · 2022-11-11T13:42:07Z (over 1 year ago)
Slight adjustment to a test case

Copy Link

Raw

Markdown

Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").
## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters
## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
- For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
- A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
- An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
- A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
- Any other character will remain unchanged
## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):
```text
:
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```
## Test cases
Test cases are in the format `"input string" : "output string"`.
```text
"gnat irk terra" : "tang vex green"
"2468" : "7913"
"#%&@,.:;?" : "#%&@,.:;?"
~~"Rot13 & Ebg68" : "Ebg68 & Rot13"~~
```

Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").
## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters
## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
- For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
- A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
- An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
- A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
- Any other character will remain unchanged
## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):
```text
:
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```
## Test cases
Test cases are in the format `"input string" : "output string"`.
```text
"gnat irk terra" : "tang vex green"
"2468" : "7913"
"#%&@,.:;?" : "#%&@,.:;?"
"Rot13.5 & Ebg68.0" : "Ebg68.0 & Rot13.5"
```

#2: Post edited by

trichoplax‭ · 2022-11-11T13:39:42Z (over 1 year ago)
Amend test cases

Copy Link

Raw

Markdown

Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").
## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters
## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
- For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
- A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
- An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
- A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
- Any other character will remain unchanged
## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):
```text
:
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```
## Test cases
Test cases are in the format `"input string" : "output string"`.
```text
~~"gnat" : "tang"~~
"2468" : "7913"
~~"Rot13" : "Ebg68"~~
~~"Ebg68" : "Rot13"~~
"#%&@,.:;?" : "#%&@,.:;?"
```

Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").
## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters
## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
- For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
- A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
- An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
- A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
- Any other character will remain unchanged
## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):
```text
:
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```
## Test cases
Test cases are in the format `"input string" : "output string"`.
```text
"gnat irk terra" : "tang vex green"
"2468" : "7913"
"#%&@,.:;?" : "#%&@,.:;?"
"Rot13 & Ebg68" : "Ebg68 & Rot13"
```

#1: Initial revision by

trichoplax‭ · 2022-11-11T13:33:26Z (over 1 year ago)

Copy Link

Raw

Markdown

Encode with ROT13.5

Given a string, convert all of its letters using ROT13, and all of its digits using ROT5. This is sometimes referred to as [ROT13.5](https://en.wikipedia.org/wiki/ROT13#Variants "Variants of ROT13 on Wikipedia").

## Input
- A sequence of printable ASCII characters (character codes 32 to 126 inclusive)
- This may be a string or any data structure of characters

## Output
- A sequence of characters
- This may be a string or any ordered data structure of characters. It does not need to match the input format (provided it is consistent between inputs)
  - For example, you may take input as an array of characters, and output as a string, provided this format does not change for different inputs
- Each character in the output will be determined by the character in the corresponding position in the input, as follows:
  - A lower case letter will be replaced with the lower case letter 13 character codes after it, wrapping back to 'a' if 'z' is exceeded
  - An upper case letter will be replaced with the upper case letter 13 character codes after it, wrapping back to 'A' if 'Z' is exceeded
  - A numeric digit will be replaced with the numeric digit 5 character codes after it, wrapping back to '0' if '9' is exceeded
  - Any other character will remain unchanged

## Conversion table
Here is the output character for every valid input character, in the format `input : output` (the first character is a space, which remains unchanged):

```text
  :  
! : !
" : "
# : #
$ : $
% : %
& : &
' : '
( : (
) : )
* : *
+ : +
, : ,
- : -
. : .
/ : /
0 : 5
1 : 6
2 : 7
3 : 8
4 : 9
5 : 0
6 : 1
7 : 2
8 : 3
9 : 4
: : :
; : ;
< : <
= : =
> : >
? : ?
@ : @
A : N
B : O
C : P
D : Q
E : R
F : S
G : T
H : U
I : V
J : W
K : X
L : Y
M : Z
N : A
O : B
P : C
Q : D
R : E
S : F
T : G
U : H
V : I
W : J
X : K
Y : L
Z : M
[ : [
\ : \
] : ]
^ : ^
_ : _
` : `
a : n
b : o
c : p
d : q
e : r
f : s
g : t
h : u
i : v
j : w
k : x
l : y
m : z
n : a
o : b
p : c
q : d
r : e
s : f
t : g
u : h
v : i
w : j
x : k
y : l
z : m
{ : {
| : |
} : }
~ : ~
```

## Test cases
Test cases are in the format `"input string" : "output string"`.

```text
"gnat" : "tang"
"2468" : "7913"
"Rot13" : "Ebg68"
"Ebg68" : "Rot13"
"#%&@,.:;?" : "#%&@,.:;?"
```

code-golf string encoding

Communities

Post History