Comme George Orwell l'a écrit en 1984 :

La guerre est la paix La
liberté est l'esclavage L'
ignorance est la force

Ecrivez un programme ou une fonction reprenant l’un des six mots principaux de la citation d’Orwell et produisant son équivalent.

Plus précisément:

[input] -> [output]
war -> peace
peace -> war
freedom -> slavery
slavery -> freedom
ignorance -> strength
strength -> ignorance

Aucune autre paire d'entrée / sortie n'est requise.

Vous devez supposer que les mots sont toujours en minuscule, comme ci-dessus. Sinon, vous pouvez supposer que les mots sont toujours entièrement en majuscules: WAR -> PEACE, PEACE -> WAR, etc.

Le code le plus court en octets gagne.

05AB1E , 30 octets

05AB1E utilise le CP-1252 .

“ignorance¤í‡î—™šÔÃÒry“#DIk1^è

Essayez-le en ligne! ou en tant que suite de tests

Explication

L'approche directe

• Pousser la ficelle ignorance strength war peace freedom slavery
• Split sur des espaces
• Récupère l'index de l'entrée dans la liste
• XOR l'index avec 1
• Obtenir l'élément dans la liste à cet index

JavaScript (ES6), 80 octets

s=>'freedom,,war,,strength,,slavery,peace,ignorance'.split`,`[s.charCodeAt(1)%9]

Comment ça fonctionne

Nous utilisons une petite table de correspondance basée sur le code ASCII du deuxième caractère de chaque mot, renvoyant l'index de son équivalent.

Word      | 2nd char. | ASCII code | MOD 9
----------+-----------+------------+------
war       | a         | 97         | 7
peace     | e         | 101        | 2
freedom   | r         | 114        | 6
slavery   | l         | 108        | 0
ignorance | g         | 103        | 4
strength  | t         | 116        | 8

En remarque, si les cas mixtes étaient autorisés, l’utilisation war PEACE FREEDOM slavery IGNORANCE strengthde modulo 6 conduirait à un hachage parfait.

Tester

let f =

s=>'freedom,,war,,strength,,slavery,peace,ignorance'.split`,`[s.charCodeAt(1)%9]

console.log('war', '->', f('war'))
console.log('peace', '->', f('peace'))
console.log('freedom', '->', f('freedom'))
console.log('slavery', '->', f('slavery'))
console.log('ignorance', '->', f('ignorance'))
console.log('strength', '->', f('strength'))

Gelée , 24 octets

“Ñ=ƘḊ¹ƥ¹Ƙ⁷ṅ8cøGị»Ḳµiɠ^1ị

Essayez-le en ligne!

Comment ça fonctionne

Tout d'abord, le jeton

“Ñ=ƘḊ¹ƥ¹Ƙ⁷ṅ8cøGị»

indexe dans le dictionnaire de Jelly pour créer la chaîne

strength war peace freedom slavery ignorance

qui Ḳse divise en espaces pour donner le tableau de chaînes

["strength", "war", "peace", "freedom", "slavery", "ignorance"]

µ commence une nouvelle chaîne monadique avec ce tableau de chaînes comme argument, qui est également la valeur de retour actuelle.

ɠlit une ligne d'entrée à partir de STDIN et itrouve son index de la valeur de retour précédente, c'est-à-dire le tableau de chaînes généré.

Maintenant, ^1prend le bit au bit XOR de cet index et 1 . Même pour les indices - rappelez - vous que les indices Jelly sont 1 à base et modulaire, la force a l' indice 1 et l' ignorance a l' indice 6 / 0 - ce incrémente l'indice; pour les indices impairs, il les diminue.

Enfin, ịrécupère la chaîne à cet index à partir de l'argument de la chaîne.

Mathematica, 84 octets

(x="war""peace")(y="freedom""slavery")(z="ignorance""strength")/#/.x->1/.y->1/.z->1&

Explication

Plus "d'arithmétique" avec des chaînes! Comme dans la réponse liée, ceci est basé sur le fait que vous pouvez "multiplier" des chaînes dans Mathematica, ce qui les laissera non évaluées (comme si vous multipliiez deux variables non affectées x*y), mais que Mathematica appliquera des simplifications de base, telles que l'annulation de facteurs dans une division.

Nous commençons donc par stocker les trois paires comme produits x, y, zrespectivement et les multiplier tous ensemble:

(x="war""peace")(y="freedom""slavery")(z="ignorance""strength")

Ceci évalue à

"freedom" "ignorance" "peace" "slavery" "strength" "war"

(Mathematica trie automatiquement les facteurs, mais l'ordre nous importe peu.)

Nous divisons cela par l'entrée pour supprimer le mot avec lequel nous ne voulons pas.../# , puisque Mathematica annule les facteurs. Par exemple, si l'entrée était "peace"nous nous retrouverions avec:

"freedom" "ignorance" "slavery" "strength" "war"

Enfin, on se débarrasse des paires que nous ne sommes pas intéressés, en substituant chacun x, yet zavec 1. Encore une fois, la simplification de Mathematica 1*aest toujours d'actualité a. Cette partie est faite avec:

/.x->1/.y->1/.z->1

La bonne chose est que Mathematica sait que la multiplication est Orderlessce qui permet de trouver les deux facteurs, qu’ils soient adjacents ou non dans le produit. Seul le mot opposé à l'entrée n'est plus associé dans le produit, de sorte que celui-ci ne sera pas supprimé et reste la seule sortie.

Vim, 60 octets

D3iwar freedom ignorance peace slavery strength <esc>2?<C-r>"
3wdwVp

Essayez-le en ligne! dans l'interpréteur V compatible avec les versions antérieures.

Bien sûr, si nous passions à V, nous pourrions économiser un octet en utilisant une méthode de saisie plus pratique. Mais comme c'est une si petite différence, je préférerais utiliser la version non-golf.

Explication:

D                       " Delete this whole line
 3i...<esc>             " Insert the text three times
           2?           " Search backwards twice
             <C-r>"     " For the words we deleted
3w                      " Move three words forward
  dw                    " Delete a word
    V                   " Select this whole line
     p                  " And paste the word we deleted over it

C (gcc) , 120 à 107 octets

f(long*s){long r[2]={0};strcpy(r,s);s=*r>>40?*r>>56?"\n":"":"CE";*r^=*s;r[1]^=69;puts(r);}

Abus maximum de pointeur! Nécessite une machine little-endian et des longs 64 bits.

Le code contient quelques éléments non imprimables, mais le copier-coller devrait toujours fonctionner.

Essayez-le en ligne!

Python, 81 octets

l='war peace freedom slavery ignorance strength'.split()
lambda s:l[l.index(s)^1]

Ou même longueur:

l='war slavery ignorance strength freedom peace'.split()
dict(zip(l,l[::-1])).get

Perl 6 , 61 octets

Avec des caractères non imprimables représentés par (car StackExchange les supprime sinon):

{first {s/^\w+<(\0*$//},["���ce","�������","���
����e"X~^$_]}

Voici un xxdvidage hexadécimal:

00000000: 7b66 6972 7374 207b 732f 5e5c 772b 3c28  {first {s/^\w+<(
00000010: 5c30 2a24 2f2f 7d2c 5b22 0704 1363 6522  \0*$//},["...ce"
00000020: 2c22 151e 0413 011d 1422 2c22 1a13 1c0a  ,".......","....
00000030: 1c06 1a0b 6522 587e 5e24 5f5d 7d0a       ....e"X~^$_]}.

Version développée (caractères non imprimables remplacés par des séquences d'échappement, espaces et commentaires ajoutés):

{    # A Lambda.
    first {                   # Return first element which:
        s/ ^ \w+ <( \0* $ //  #   after stripping \0 has only word characters left.
    },
    [                                                  # The array to search:
        "\x[7]\x[4]\x[13]ce",                          #   "war" xor "peace"
        "\x[15]\x[1e]\x[4]\x[13]\x[1]\x[1d]\x[14]",    #   "freedom" xor "slavery"
        "\x[1a]\x[13]\x[1c]\n\x[1c]\x[6]\x[1a]\x[b]e"  #   "ignorance" xor "strength"
        X~^ $_                                         #   each xor'ed with the input.
    ]
}

Bash , 100 87 86 78 octets

a=peace;e=war;r=slavery;l=freedom;g=strength;t=ignorance;x=${1:1:1};echo ${!x}

Essayez-le en ligne!

La deuxième lettre de chaque mot identifie de manière unique ce mot, j'utilise donc ce caractère comme nom de variable; la valeur de cette variable est l'autre mot correspondant.

Par exemple, la deuxième lettre de peaceis eet le mot correspondant à peaceis war, je mets donc e=war.

Étant donné une chaîne d'entrée, le deuxième caractère de cette chaîne est utilisé comme nom de variable pour extraire le mot correspondant souhaité, en utilisant le développement de paramètre indirect de bash.

TI-Basic, 103 84 77 octets

Réduire à une ligne a sauvé beaucoup d'octets! Haha, combien cette déclaration était ironique ...

inString("EALRGT",sub(Ans,2,1
sub("WAR  PEACE FREEDOMSLAVERY STRENGTH IGNORANCE ",9Ans+1,4+Ans

Perl , 63 octets

62 octets + -pdrapeau.

$_=(slavery,freedom,ignorance,strength,war,peace)[(ord)%6+/h/]

Essayez-le en ligne!

ordrenvoie le code de caractère du premier caractère du mot saisi.
Après le %6, nous avons:

- liberté => ord = 102 =>% 6 = 0  
- esclavage => ord = 115 =>% 6 = 1  
- ignorance => ord = 105 =>% 6 = 3  
- force => ord = 115 =>% 6 = 1  
- guerre => ord = 119 =>% 6 = 5  
- peace => ord = 112 =>% 6 = 4  

Donc nous avons slaveryet strengthtous les deux retournant 1 (puisqu'ils commencent tous les deux par la même lettre), et aucun retournant 2. Par conséquent, nous ajoutons 1pour strength(c'est le seul mot qui va correspondre /h/), et nous avons chaque mot assigné à un index de 0 à 5

R, 86 87 92 octets

Changé en une fonction sans nom et gsuben subquelques octets. Le grepdétermine laquelle des 3 chaînes est utilisée et l'entrée est supprimée de cette chaîne avec sub.

function(v)sub(v,'',(l=c("warpeace","freedomslavery","ignorancestrength"))[grep(v,l)])

PHP, 70 octets

<?=[ignorance,peace,slavery,strength,freedom,war][md5("^$argv[1]")%7];

Befunge, 89 88 octets

<>_00g1v2+%7~%2~"slavery"0"war"0"freedom"0"ignorance"0"strength"0"peace"
 |p00:-<
@>:#,_

Essayez-le en ligne!

Explication

Nous commençons par placer toutes les chaînes de sortie possibles sur la pile, terminées par null. Cette séquence est exécutée de droite à gauche afin que les valeurs soient inversées, car c’est dans cet ordre que les caractères seront nécessaires lorsqu’ils seront finalement affichés.
Nous lisons ensuite les deux premiers caractères de stdin, ce qui est tout ce dont nous avons besoin pour identifier la chaîne de saisie. Si nous prenons la valeur ASCII de la première lettre mod 2, plus la deuxième lettre mod 7, nous obtenons un nombre unique compris entre 2 et 7.

Input         ASCII      %2 %7   Sum
[fr]eedom     102 114    0  2    2
[pe]ace       112 101    0  3    3
[sl]avery     115 108    1  3    4
[st]rength    115 116    1  4    5
[ig]norance   105 103    1  5    6
[wa]r         119 97     1  6    7

Ce nombre peut ensuite être utilisé comme une sorte d’index dans la liste de chaînes de la pile. Nous décrémentons de façon itérative l'index (la première fois de 2) et, pour chaque itération, nous effaçons une chaîne de la pile avec la séquence >_.
Une fois que l'index atteint zéro, il reste la chaîne de sortie correcte en haut de la pile. Nous utilisons donc une séquence de sortie de chaîne simple pour écrire le résultat sur stdout.

Pyke, 29 octets

.d⻌૽ɦڷࠛ⯤dci@1.^iR@

Essayez-le ici!

.d⻌૽ɦڷࠛ⯤           -     "war peace freedom slavery ignorance strength"
         dc         -     ^.split(" ")
           i        -    i=^
            @       -   ^.find(input)
             1.^    -  ^ xor 1
                iR@ - input[^]

C, 93

@ La réponse d'Arnauld a été portée à C

#define F(w)(char*[]){"freedom",0,"war",0,"strength",0,"slavery","peace","ignorance"}[w[1]%9]

C (gcc) , 113 108 octets

f(char*s){char*t="5WAR\0+PEACE\09FREEDOM\0'SLAVERY\0;IGNORANCE\0%STRENGTH";while(strcmp(s,++t));puts(t+*--t-47);}

Toutes les instances de \0peuvent être remplacées par des octets NUL réels à des fins de scoring.

t+*--t-47est un comportement indéfini; cela peut / ne fonctionnera pas avec d'autres compilateurs.

Essayez-le en ligne!

JavaScript (ES6), 71 78

Tellement ennuyeux que la réponse d'Arnauld, mais aussi plus court.

Maintenant, j'ai ajouté l'encodage avec btoa. Dans la chaîne codée, il y a 4 octets que je ne peux pas publier sur ce site, même s'il s'agit de caractères valides dans une chaîne javascript. J'ai donc utilisé un hex d'échappement dans la forme \xHH. Chacune de ces échappées compte pour 1 octet.

La chaîne encodée est strength0ignorance0peace0war0slavery0freedom

x=>(w=btoa`²ÚÞ\x9e\x0baÒ('¢¶§qí)y§\x1eÓ\x06«ÒÉZ½êòÑúÞyÚ&`.split(0))[w.indexOf(x)^1]

Celui-ci est 82 et insensible à la casse

x=>',,strength,,slavery,war,,,ignorance,peace,freedom'.split`,`[parseInt(x,36)%15]

Tester

F=
x=>(w=btoa`²ÚÞ\x9e\x0baÒ('¢¶§qí)y§\x1eÓ\x06«ÒÉZ½êòÑúÞyÚ&`.split(0))[w.indexOf(x)^1]

;['freedom','slavery','war','peace','ignorance','strength']
.forEach(w=>console.log(w + ' -> ' + F(w)))

CJam, 52 (ASCII seulement)

"/.|Mv
DO'y    EK{ {:nBct'Pt}d4sE"144b26b'af+'j/_ra#1^=

Essayez-le en ligne

Note: les espaces sont des caractères de tabulation (un avant et un après "EK {")

Explication:

La partie allant jusqu'à "+" décompresse la chaîne "slaveryjfreedomjwarjpeacejignorancejstrength", en utilisant la conversion de base:
string (traité comme un tableau de codes de caractères) → (base 144) nombre → (base 26) tableau de nombres → (en ajoutant "a" à chaque nombre) chaîne

'j/    split around 'j' characters
_      duplicate the resulting word array
ra     read the input and wrap in array
#      find the index of the input in the word array
1^     XOR with 1
=      get the word at the new index

> <> (Poisson), 84 78 octets

0i~ia%.
v'raw'
>ol?!;
^'htgnerts'
^'yrevals'

^'ecnarongi'
^'ecaep'
^'modeerf'

Essayez-le en ligne!

Nous commençons à nager en haut à gauche, en allant à droite. Nous lançons d’abord la pile avec un 0. Ensuite, nous lisons la première lettre de input ( i), nous l’évincons ( ~), lisons la deuxième lettre ( i) et réduisons sa valeur ASCII modulo 10 ( a%). Ceci mappe a, e, r, l, g et t sur 7, 1, 4, 8, 3 et 6, respectivement - appelons ce nombre N. .extrait deux valeurs de la pile - N et 0 - et saute à ligne N, caractère 0.

Après un saut, le poisson effectue un tic-tac avant d'exécuter les instructions. Il ignore donc le premier caractère et traverse la ligne N, ce qui charge le mot correspondant dans la pile. Enfin, nous allons à la ligne 2, qui sort la pile entière et sort.

• Sauvegardé six octets en utilisant un saut, au lieu de la modification de code cool que j'ai utilisé auparavant. Tant pis.

JavaScript, 78 octets

w=>(a="war slavery ignorance strength freedom peace".split` `)[5-a.indexOf(w)]

C'est un genre de port de ma réponse en Python . Nous stockons les mots dans une chaîne où chacun se trouve dans la position opposée à celle de son équivalent. Nous trouvons l'index du mot donné wet obtenons cet index à la fin pour renvoyer le résultat.

Extrait de test:

f = w=>(a="war slavery ignorance strength freedom peace".split` `)[5-a.indexOf(w)]

console.log(f("peace"))
console.log(f("ignorance"))
console.log(f("war"))

Paris / GP, 86 octets

Pari / GP est un interpréteur interactif, nous n’avons pas besoin d’un "print" -cmd pour la sortie; Cependant, l'utilitaire Try-It_Online a besoin d'un "print" -cmd, je l'ai donc séparé en "pied de page".
Nous définissons une "fonction-objet" (la lettre O me rappelle joliment la fonction Orwell ... ;-)):

x.O=s=[war,freedom,ignorance,strength,slavery,peace];for(k=1,6,if(x==s[k],i=7-k));s[i]

Après cela, appelez

print(war.O)   \\ input to Pari/GP with the O-rwell-member of "war"
       peace   \\ output by Pari/GP

Essayez-le en ligne!

(Notez que dans Pari / GP, les jetons donnés ici ne sont pas des chaînes mais des noms de variables légaux! Ces variables ne devraient jamais avoir de valeur assignée à)

Empilé, 70 octets

@x'war
strength
freedom
slavery
ignorance
peace'LF split:x index\rev\#

Essayez-le ici! Prend l'entrée sur la pile et laisse la sortie sur la pile. Par exemple:

'war'

@x'war
strength
freedom
slavery
ignorance
peace'LF split:x index\rev\#

out

Ce code est assez explicite. Légèrement modifié pour exécuter tous les cas de test:

('war' 'slavery' 'ignorance')
{x:'war
strength
freedom
slavery
ignorance
peace'LF split:x index\rev\#x\,}"!
disp

Jolf, 35 octets

.γG"ΞΠΞ¦ΞpΞsΞΈΞ3I"-5 iγ

Il y a beaucoup de non imprimables. Voici un vidage d'hex, bien que cela ne fasse pas beaucoup de bien:

00000000: 2ece b347 22ce 9e07 cea0 c28e ce9e 07c2  ...G"...........
00000010: 8ac2 a6ce 9e06 c28e 70ce 9e07 73c2 8fce  ........p...s...
00000020: 9e06 ce88 c280 ce9e 0133 4922 052d 3520  .........3I".-5
00000030: 69ce b3                                  i..

Voici un lien en ligne.

En gros, le code ressemble à ceci:

.γG"..."♣-5 iγ
  G"..."♣        split uncompressed string on spaces
 γ               set gamma to this
            iγ   index of the input in gamma
.γ       -5      and get 5 - this from gamma

En fait , 56 octets

' "war peace freedom slavery ignorance strength"s;)í1^@E

Essayez-le en ligne!

Malheureusement, sans compression intégrée, il est plus court de ne pas compresser la chaîne et de la décompresser manuellement.

Explication:

' "war peace freedom slavery ignorance strength"s;)í1^@E
' "war peace freedom slavery ignorance strength"s         split the string on spaces
                                                 ;)       make a copy, push it to the bottom of the stack
                                                   í      index of input in list
                                                    1^    XOR with 1
                                                      @E  that element in the list

Haskell, 104 111 octets

data O=WAR|FREEDOM|IGNORANCE|PEACE|SLAVERY|STRENGTH deriving(Show,Enum)
f s=toEnum$mod(3+fromEnum s)6::O

Idée:

• Énumérer les mots-clés de telle sorte que leur contrepartie se trouve à 3 positions
• Prenez le mot-clé, obtenez sa position par fromEnum, déplacez 3 étapes vers la droite (module 6) et reconvertissez-le en mot-clé.
• Le ::Oest nécessaire car l'inférence de type a quelques problèmes. Donner fune signature f :: O -> Oaurait le même effet, mais ce n’est pas si court.

Modifier:

Remplacé

f s=toEnum$mod(3+fromEnum s)6

par

f=toEnum.(`mod`6).(+3).fromEnum

grâce à @Laikoni.

Dyalog APL , 66 octets

Soit l'un de ceux-ci:

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞utilise cette méthode (requiert ⎕IO←0ce qui est la valeur par défaut sur de nombreux systèmes).

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ effectue une recherche, puis sélectionne l'élément correspondant dans la liste inversée.

Qbasic, 138 à 99 octets

D$="ignorancefreedom  peace    strength slavery  war      ":INPUT A$:?MID$(D$+D$,INSTR(D$,A$)+27,9)

D$stocke tous les mots du côté gauche du mantra, puis tous ceux du côté droit. Chaque mot est rempli d'espaces avec exactement 9 lettres par mot. D$est ensuite ajouté à lui-même.

Puis instrest utilisé pour trouver l'index du mot entré par l'utilisateur. L’autre partie du mantra est toujours stockée exactement 9 * 3 positions plus loin dans la chaîne, nous imprimons donc une sous-chaîne commençant à cette position, en prenant 9 caractères.

SmileBASIC, 92 octets

A$="PEACE
E$="WAR
R$="SLAVERY
L$="FREEDOM
G$="STRENGTH
T$="IGNORANCE
INPUT I$?VAR(I$[1]+"$")

Python , 80 octets

En quelque sorte, xnor est devenu un golf!

C'est une fonction lambda sans nom, qui renvoie le résultat.

lambda w,a="war slavery ignorance strength freedom peace".split():a[~a.index(w)]

Essayez-le en ligne!

La liste de mots est agencée de telle sorte que chacun se trouve dans la position opposée à celle de son homologue. Étant donné le mot w, nous trouvons son index dans la liste de mots, puis bitwise PAS ( ~). Cela retourne tous les bits, ce qui est calculé n => -n-1. En raison de l'indexation négative de Python, obtient l'index opposé dans la liste.

En tant que sorte de bonus non intentionnel, vous pouvez transmettre n'importe quelle liste de mots d'opposés à cette fonction en tant que second argument.