# Source permutation

A permutation of a set $$\S = \{s_1, s_2, \dotsc, s_n\}\$$ is a bijective function $$\\pi: S \to S\$$. For example, if $$\S = \{1,2,3,4\}\$$ then the function $$\\pi: x \mapsto 1 + (x + 1 \mod 4)\$$ is a permutation:

$$\pi(1) = 3,\quad \pi(2) = 4,\quad \pi(3) = 1,\quad \pi(4) = 2$$

We can also have permutations on infinite sets, let's take $$\\mathbb{N}\$$ as an example: The function $$\\pi: x \mapsto x-1 + 2\cdot(x \mod 2)\$$ is a permutation, swapping the odd and even integers in blocks of two. The first elements are as follows:

$$2,1,4,3,6,5,8,7,10,9,12,11,14,13,16,15,\dotsc$$

## Challenge

Your task for this challenge is to write a function/program implementing any1 permutation on the positive natural numbers. The score of your solution is the sum of codepoints after mapping them with the implemented permutation.

## Example

Suppose we take the above permutation implemented with Python:

def pi(x):
return x - 1 + 2*(x % 2)


Try it online!

The character d has codepoint $$\100\$$, $$\\texttt{pi}(100) = 99\$$. If we do this for every character, we get:

$$99,102,101,31,111,106,39,119,42,57,9,31,31,31,31,113,102,115,118,113,109,31,119,31,46,31,50,31,44,31,49,41,39,119,31,38,31,49,42$$

The sum of all these mapped characters is $$\2463\$$, this would be the score for that function.

## Rules

You will implement a permutation $$\\pi\$$ either as a function or program

• given an natural number $$\x\$$, return/output $$\\pi(x)\$$
• for the purpose of this challenge $$\\mathbb{N}\$$ does not contain $$\0\$$
• the permutation must non-trivially permute an infinite subset of $$\\mathbb{N}\$$
• your function/program is not allowed to read its own source

## Scoring

The score is given by the sum of all codepoints (zero bytes may not be part of the source code) under that permutation (the codepoints depend on your language2, you're free to use SBCS, UTF-8 etc. as long as your language supports it).

The submission with the lowest score wins, ties are broken by earliest submission.

1. Except for permutations which only permute a finite subset of $$\\mathbb{N}\$$, meaning that the set $$\\{ x | \pi(x) \neq x \}\$$ must be infinite.

2. If it improves your score, you can for example use a UTF-8 encoded Jelly submission instead of the usual SBCS.

• @JoKing "zero bytes may not be part of the source code" re: the second question – ASCII-only Mar 11 '19 at 1:11
• – Peter Taylor Mar 11 '19 at 11:16

# Jelly, score  288 250 212  199

-38 thanks to Erik the Outgolfer!

C-*+


Swaps even with odd.

The score is $$\67+45+44+43=199\$$ - see self-scoring here.

Try it online!

• Apparently, Leaky Nun's -*ạ has a score of 300... however, -*_@ has a score of 250. Maybe I should post that as my own, although it's the same permutation. – Erik the Outgolfer Mar 10 '19 at 17:42
• Ah nice observation by Leaky Nun, so -*N+ scores 212 – Jonathan Allan Mar 10 '19 at 17:52
• It wasn't an observation, it was a self-answer to his (now pretty old) challenge. ;-) – Erik the Outgolfer Mar 10 '19 at 17:52
• C-*+ sound like some future variation of C++. – val is still with Monica Mar 11 '19 at 5:50

# JavaScript (ES6), Score =  276  268

$=>(--$^40)+!0


Try it online!

• but 54^54 is 0 – Jonathan Allan Mar 10 '19 at 17:56
• @JonathanAllan Thanks for notifying. I somehow missed that part. Should be correct now. – Arnauld Mar 10 '19 at 18:04

# Perl 6, Score: 201

*-!0+^40+!0


Try it online!

Port of Arnauld's answer. This benefits from xor (+^) having the same precedence as - and +, and the use of a Whatever lambda to reduce overall characters. Other than that, I couldn't find a way of representing it differently that got a better score.

# Perl 6, Score 804 702

{{(++$∉ords(q[!$%()+-2?[]_doqrsx{}∉])??++$+22-$++%2-$++%2!!++$)xx$_}()[-!$+\$_]}


Try it online!

The first quine-y type answer here, and I think it scores pretty well.

This produces the sequence $$\23,22,25,24...\$$ from the question body with the range $$\1,2,3,4...21\$$ inserted at the indexes of the unique sorted codepoints of the code. For example, the 30th through 35th elements of the sequence are $$\50, 53, 52, 1, 55, 54\$$ since the 33rd codepoint is ! and that's the lowest codepoint in my code.

• O_o that's a massive improvement – ASCII-only Mar 11 '19 at 6:52

# Python 2 score: 742698 694 points

lambda a:a^96or~~96


Try it online!

-44 points thanks to Ørjan Johansen; -4 points thx to xnor.

• Ørjan Johansen: Fixed (and it saved me 44 bytes!) – Chas Brown Mar 14 '19 at 23:48
• Good save (although that's not bytes) – Ørjan Johansen Mar 14 '19 at 23:50
• That's some generous crediting! – Ørjan Johansen Mar 14 '19 at 23:51
• Wouldn't have edited if you hadn't pointed out the flaw :) – Chas Brown Mar 14 '19 at 23:53
• It's cheaper to replace the space before 96 with ~~. – xnor Mar 15 '19 at 0:27

# Retina 0.8.2, 6 bytes, score 260

TORO


Try it online! Link includes self-scoring footer. Simply swaps digits 1 and 9 and 3 and 7 in the decimal representations, so that numbers that contain no digits coprime to 10 are unaffected.

# C# (Visual C# Interactive Compiler), 22 bytes, Score 247 245

A=>A>65?A-1+A%2*2:66-A


Try it online!

Simple, if less than 66, return 66 minus input, else use the formula in the question that swaps even and odd numbers.

• What's wrong with the previous version A=>A<66?66-A:A? – Jo King Mar 11 '19 at 2:35
• @JoKing Except for permutations which only permute a finite subset of $\mathbb{N}$, meaning that the set $\{ x | \pi(x) \neq x \}$ must be infinite. The set isn't infinite, since the only values in the set are 1-65, since above 65, all values of A map to A – Gymhgy Mar 11 '19 at 2:37
• Oh darn, I didn't notice that. That means my own answer is invalid too :( – Jo King Mar 11 '19 at 2:40

# TI-BASIC, 9 bytes, score 10881051 1000

Ans-cos(π2fPart(2⁻¹Ans


Swaps even with odd. Even maps to Ans-1 and odd maps to Ans+1.

TI-BASIC is tokenized, so this program will have the following hex-values:

Ans   -    cos(  π    2    fPart(  2   ⁻¹  Ans
72    71   C4    AC   32   BA      32  0C  72


Thus the score is: $$\113+114+195+171+49+185+49+11+113=1000\$$

Output test program:

For(I,1,10
I
Ans-cos(π2fPart(2⁻¹Ans
Disp Ans
Pause
End


Which outputs:

2
1
4
3
6
5
8
7
10
9


Notes:

• TI-BASIC's token values can be found here.

• Pause is used in the output program to better see the permutation, as the calculator only has 8 lines. Press [ENTER] to view the next permutation.

# Charcoal, 13 bytes, score 681

⁻⁺²³²ι⊗﹪⊖ι²³³


Try it online! Link is to self-scoring version with header to map over an array of byte codes. (Charcoal has a custom code page so I've manually inserted the correct byte codes in the input.) Works by reversing ranges of 233 numbers, so that 117, 350, 583 ... are unchanged. Explanation:

     ι          Value
⁺              Plus
²³²           Literal 232
⁻               Minus
ι      Value
⊖       Decremented
﹪        Modulo
²³³   Literal 233
⊗         Doubled


# Haskell, score 985

(\((.),(-))->(.)*200+mod(-39+(-))200+1).(\(*)->divMod((*)-1)200)


Try it online!

• I don't think this is a permutation, since adding a*200 has no effect modulo 200 so a doesn't matter. – xnor Mar 10 '19 at 22:34
• @xnor Good catch. That's supposed to be outside of the mod. At some point while golfing, I must have messed up order of operations. Fixed now, thanks! – Joseph Sible-Reinstate Monica Mar 10 '19 at 22:52
• I think there's another issue that 40 maps to 0 but the challenge requires positive integers, which makes approaches like this tricky. – xnor Mar 10 '19 at 23:15
• Using sum[1|...] over if..then..else should help. – ბიმო Mar 11 '19 at 0:09
• – ASCII-only Mar 11 '19 at 1:18

# 05AB1E, score: 488 in 05AB1E's code page

È·<-


Swaps odd and even like the example function.

Will try to improve the score from here.

Explanation:

È     # Check if the (implicit) input is even (1 if truthy; 0 if falsey)
·    # Double (2 if truthy; 0 if falsey)
<   # Decrease by 1 (1 if truthy; -1 if falsey)
-  # Subtract it from the (implicit) input (and output implicitly)


# Brainfuck, 47 bytes, score 2988

,[-<+<+>>]<[->[>+<[-]]+>[<->-]<<]>[-<<++>>]<<-.


Try it online!

I used the permutation given in the introduction. Since this is bijection you can use it as a simple symmetric cipher similar to ROT13 or Atbash. My solution works on unbounded cells. However, by restricting yourself to 8-bit cells, you could save 2 points by replacing [-] with [+].