Une permutation d'un ensemble $S = \{s_1, s_2, \dotsc, s_n\}$ est une bijective fonction . Par exemple, si alors la fonction est une permutation:$\pi: S \to S$$S = \{1,2,3,4\}$$\pi: x \mapsto 1 + (x + 1 \mod 4)$

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

Nous pouvons également avoir des permutations sur des ensembles infinis, prenons comme exemple: La fonction est une permutation, permutant l'impair et même entiers par blocs de deux. Les premiers éléments sont les suivants:$\mathbb{N}$$\pi: x \mapsto x-1 + 2\cdot(x \mod 2)$

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

Défi

Votre tâche pour ce défi est d'écrire une fonction / programme mettant en oeuvre une ¹ permutation sur les nombres naturels positifs. Le score de votre solution est la somme des points de code après leur mise en correspondance avec la permutation implémentée.

Exemple

Supposons que nous prenions la permutation ci-dessus implémentée avec Python:

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

Essayez-le en ligne!

Le caractère da un point de code , . Si nous faisons cela pour chaque personnage, nous obtenons:$100$$\texttt{pi}(100) = 99$

$$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$$

La somme de tous ces caractères mappés est , ce serait le score de cette fonction.$2463$

Règles

Vous allez implémenter une permutation en tant que fonction ou programme$\pi$

• étant donné un nombre naturel , retour / sortie$x$$\pi(x)$
• aux fins de ce défi ne contient pas$\mathbb{N}$$0$
• la permutation doit permuter non trivialement un sous-ensemble infini de$\mathbb{N}$
• votre fonction / programme n'est pas autorisé à lire sa propre source

Notation

Le score est donné par la somme de tous les points de code (zéro octet peut ne pas faire partie du code source) sous cette permutation (les points de code dépendent de votre langue ² , vous êtes libre d'utiliser SBCS, UTF-8, etc. tant que votre langue le prend en charge).

La soumission avec le score le plus bas gagne, les égalités sont rompues par la soumission la plus ancienne.

---

1. À l'exception des permutations qui ne permutent qu'un sous-ensemble fini de $\mathbb{N}$ , ce qui signifie que l'ensemble doit être infini.$\{ x | \pi(x) \neq x \}$

2. Si cela améliore votre score, vous pouvez par exemple utiliser une soumission Jelly encodée en UTF-8 au lieu du SBCS habituel.

Jelly , score  288 250 212  199

-38 merci à Erik l'Outgolfer!

C-*+

Échange même avec impair.

Le score est de $67+45+44+43=199$ - voir auto-score ici .

Essayez-le en ligne!

JavaScript (ES6), score =  276  268

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

Essayez-le en ligne!

Perl 6 , score: 201

*-!0+^40+!0

Essayez-le en ligne!

Réponse du port d' Arnauld . Cela profite de xor ( +^) ayant la même priorité que -et +, et de l'utilisation d'un lambda Quel que soit pour réduire les caractères globaux. En dehors de cela, je n'ai pas pu trouver un moyen de le représenter différemment qui a obtenu un meilleur score.

Perl 6 , score 804 702

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

Essayez-le en ligne!

La première réponse de type quine-y ici, et je pense qu'elle réussit assez bien.

Cela produit la séquence $23,22,25,24...$ partir du corps de la question avec la plage $1,2,3,4...21$ insérée aux index des points de code triés uniques du code. Par exemple, les 30ème à 35ème éléments de la séquence sont $50, 53, 52, 1, 55, 54$ puisque le 33ème point de code est !et c'est le point de code le plus bas de mon code.

Score Python 2 : 742 698 694 points

lambda a:a^96or~~96

Essayez-le en ligne!

-44 points grâce à Ørjan Johansen; -4 points thx à xnor.

Retina 0.8.2 , 6 octets, score 260

T`O`RO

Essayez-le en ligne! Le lien inclut un pied de page auto-scorant. Échange simplement les chiffres 1et 9et 3et 7dans les représentations décimales, de sorte que les nombres qui ne contiennent pas de chiffres coprime vers ne 10soient pas affectés.

C # (Visual C # Interactive Compiler) , 22 octets, score 247 245

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

Essayez-le en ligne!

Simple, s'il est inférieur à 66, renvoie 66 moins d'entrée, sinon utilisez la formule de la question qui permute les nombres pairs et impairs.

TI-BASIC, 9 octets, score 1088 1051 1000

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

Échange même avec impair. Cartes Ans-1paires et cartes impaires Ans+1.

TI-BASIC est tokenisé, donc ce programme aura les valeurs hexadécimales suivantes:

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

Ainsi, le score est: $113+114+195+171+49+185+49+11+113=1000$

Programme de test de sortie:

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

Quelles sorties:

2
1
4
3
6
5
8
7
10
9

---

Remarques:

• Les valeurs des jetons de TI-BASIC peuvent être trouvées ici .

• Pauseest utilisé dans le programme de sortie pour mieux voir la permutation, car la calculatrice n'a que 8 lignes. Appuyez sur [ENTER] pour afficher la permutation suivante.

Fusain , 13 octets, score 681

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

Essayez-le en ligne! Le lien est vers une version à auto-évaluation avec en-tête pour mapper sur un tableau de codes d'octets. (Le charbon de bois a une page de codes personnalisée, j'ai donc inséré manuellement les codes d'octets corrects dans l'entrée.) Fonctionne en inversant les plages de 233 nombres, de sorte que 117, 350, 583 ... restent inchangés. Explication:

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

Haskell, score 985

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

Essayez-le en ligne!

05AB1E , score: 488 dans la page de codes de 05AB1E

È·<-

Échange impair et même comme la fonction d'exemple.

J'essaierai d'améliorer le score d'ici.

Essayez-le en ligne avec une entrée dans la gamme[1, 100] ou essayez-le en ligne avec les points de code.

Explication:

È     # 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 octets, score 2988

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

Essayez-le en ligne!

J'ai utilisé la permutation donnée dans l'introduction. Comme il s'agit d'une bijection, vous pouvez l'utiliser comme un simple chiffrement symétrique similaire à ROT13 ou Atbash. Ma solution fonctionne sur des cellules illimitées. Cependant, en vous limitant aux cellules 8 bits, vous pourriez économiser 2 points en les remplaçant [-]par [+].