Como George Orwell escribió en 1984 :

La guerra es paz La
libertad es esclavitud La
ignorancia es fuerza

Escriba un programa o función que tome una de las seis palabras principales de la cita de Orwell y genere su contraparte.

Específicamente:

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

No se requieren otros pares de entrada / salida.

Debe suponer que las palabras siempre están en minúsculas, como se indicó anteriormente. Alternativamente, se puede suponer las palabras son siempre totalmente en mayúsculas: WAR -> PEACE, PEACE -> WAR, etc.

El código más corto en bytes gana.

05AB1E , 30 bytes

05AB1E utiliza CP-1252 .

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

El enfoque directo

• Empujar la cuerda ignorance strength war peace freedom slavery
• Split en espacios
• Obtenga el índice de la entrada en la lista
• XOR el índice con 1
• Obtenga el elemento en la lista en ese índice

JavaScript (ES6), 80 bytes

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

Cómo funciona

Utilizamos una pequeña tabla de búsqueda basada en el código ASCII del segundo carácter de cada palabra, devolviendo el índice de su contraparte.

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

Como nota al margen, si se permitiera la war PEACE FREEDOM slavery IGNORANCE strengthcombinación de mayúsculas y minúsculas, el uso con el módulo 6 conduciría a un hash perfecto.

Prueba

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'))

Jalea , 24 bytes

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

Pruébalo en línea!

Cómo funciona

Primero, el token

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

indexa en el diccionario de Jelly para crear la cadena

strength war peace freedom slavery ignorance

que se Ḳdivide en espacios para producir el conjunto de cadenas

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

µ comienza una nueva cadena monádica, con ese conjunto de cadenas como argumento, que también es el valor de retorno actual.

ɠlee una línea de entrada de STDIN y iencuentra su índice del valor de retorno anterior, es decir, la matriz de cadenas generada.

Ahora, ^1toma el XOR bit a bit de ese índice y 1 . Para los índices incluso - tener en cuenta que los índices de jalea son 1 basada y modular, por lo que la fuerza tiene índice 1 y la ignorancia tiene índice 6 / 0 - esto incrementa el índice; para índices impares, los disminuye.

Finalmente, ịrecupera la cadena en ese índice del argumento de la cadena.

Mathematica, 84 bytes

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

Explicación

Más "aritmética" con cuerdas! Como en la respuesta vinculada, esto se basa en el hecho de que puede "multiplicar" cadenas en Mathematica, lo que las dejará sin evaluar (similar a multiplicar dos variables no asignadas x*y), pero que Mathematica aplicará simplificaciones básicas, como cancelar factores en una división.

Así que empezamos mediante el almacenamiento de los tres pares como productos en x, y, z,, respectivamente, y se multiplican a todos juntos:

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

Esto evalúa a

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

(Mathematica clasifica automáticamente los factores, pero no nos importa el orden).

Dividimos esto por la entrada para eliminar la palabra con la que no queremos .../#, ya que Mathematica cancela los factores. Por ejemplo, si la entrada fuera "peace", terminaríamos con:

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

Por último, nos deshacemos de los pares que no le interesa, sustituyendo cada una de x, yy zcon 1. Una vez más, la simplificación de Mathematica comienza 1*asiempre a. Esta parte se realiza con:

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

Lo bueno es que Mathematica sabe que la multiplicación es Orderlessasí que esto encontrará los dos factores independientemente de si son adyacentes en el producto o no. Solo la palabra que es opuesta a la entrada ya no está emparejada en el producto, por lo que no se eliminará y permanecerá como la única salida.

Vim, 60 bytes

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

Pruébalo en línea! en el intérprete de V compatible con versiones anteriores.

Por supuesto, si tuviéramos que cambiar a V, podríamos guardar un byte utilizando un método de entrada más conveniente. Pero como esta es una diferencia tan pequeña, preferiría usar la versión que no sea de golf.

Explicación:

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 bytes

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

Máximo abuso de puntero! Requiere una máquina little endian y largos de 64 bits.

El código contiene algunos elementos no imprimibles, pero el pegado de copias debería funcionar.

Pruébalo en línea!

Python, 81 bytes

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

O, misma longitud:

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

Perl 6 , 61 bytes

Con los caracteres no imprimibles que se muestran como (porque StackExchange los elimina de lo contrario):

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

Aquí hay un xxd volcado hexadecimal:

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~^$_]}.

Versión ampliada (caracteres no imprimibles reemplazados por secuencias de escape, y espacios en blanco y comentarios agregados):

{    # 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 bytes

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

Pruébalo en línea!

La segunda letra de cada palabra identifica de manera única esa palabra, por lo que uso ese carácter como nombre de variable; El valor de esa variable es la otra palabra correspondiente.

Por ejemplo, la segunda letra de peacees e, y la palabra correspondiente a peacees war, así que configurée=war .

Dada una cadena de entrada, el segundo carácter de esa cadena se usa como un nombre de variable para extraer la palabra correspondiente deseada, utilizando la expansión de parámetros indirectos de bash.

TI-Basic, 103 84 77 bytes

¡Reducir a una sola línea ahorró muchos bytes! Jaja, qué irónico fue esa declaración ...

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

Perl , 63 bytes

62 bytes + -pbandera.

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

Pruébalo en línea!

orddevuelve el código char del primer carácter de la palabra de entrada.
Después de la%6 , tenemos:

- libertad => ord = 102 =>% 6 = 0  
- esclavitud => ord = 115 =>% 6 = 1  
- ignorancia => ord = 105 =>% 6 = 3  
- fuerza => ord = 115 =>% 6 = 1  
- guerra => ord = 119 =>% 6 = 5  
- paz => ord = 112 =>% 6 = 4  

Entonces tenemos slaveryy strengthambos devolviendo 1 (ya que ambos comienzan con la misma letra), y ninguno devolviendo 2. Por lo tanto, agregamos 1para strength(es la única palabra que coincidirá /h/), y tenemos cada palabra asignada a un índice de 0 a 5)

R, 86 87 92 Bytes

Cambiado a una función sin nombre y gsubal subde unos pocos bytes. Los grepdetermina cuál de las 3 cadenas se utiliza y la entrada se quita de esa cadena con sub.

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

PHP, 70 bytes

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

Befunge, 89 88 bytes

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

Pruébalo en línea!

Explicación

Comenzamos empujando todas las cadenas de salida posibles en la pila, terminadas en nulo. Esta secuencia se ejecuta de derecha a izquierda para que los valores se introduzcan en reversa, ya que ese es el orden en que se necesitarán los caracteres cuando finalmente se generen.
Luego leemos los primeros dos caracteres de stdin, que es todo lo que necesitamos para identificar la cadena de entrada. Si tomamos el valor ASCII de la primera letra mod 2, más la segunda letra mod 7, obtenemos un número único en el rango de 2 a 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

Este número se puede usar como una especie de índice en la lista de cadenas de la pila. Disminuimos iterativamente el índice (la primera vez en 2), y para cada iteración borramos una cadena de la pila con la secuencia >_.
Una vez que el índice llega a cero, nos queda la cadena de salida correcta en la parte superior de la pila, por lo que usamos una secuencia de salida de cadena simple para escribir el resultado en stdout.

Pyke, 29 bytes

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

Pruébalo aquí!

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

C, 93

La respuesta de @ Arnauld se transfirió a C

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

C (gcc) , 113108 bytes

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

Todas las instancias de \0se pueden reemplazar con bytes NUL reales para fines de puntuación.

t+*--t-47es un comportamiento indefinido; esto puede / no funcionará con otros compiladores.

Pruébalo en línea!

JavaScript (ES6), 71 78

Mucho más aburrido que la respuesta de Arnauld, pero también más corto.

Ahora agregué la codificación con btoa. En la cadena codificada hay 4 bytes que no puedo publicar en este sitio, incluso si son caracteres válidos en una cadena de JavaScript. Así que usé un escape hexadecimal en el formulario \xHH. Cada uno de estos escapes se cuenta como 1 byte.

La cadena codificada es strength0ignorance0peace0war0slavery0freedom

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

Este es 82 y no distingue mayúsculas de minúsculas

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

Prueba

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 (solo ASCII)

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

Pruébalo en línea

Nota: las cosas que parecen espacios son caracteres de tabulación (uno antes y otro después de "EK {")

Explicación:

La parte hasta "+" es descomprimir la cadena "esclavitudj libertadjwarjpeacejignorancejstrength", utilizando la conversión base:
cadena (tratada como una matriz de códigos de caracteres) → (base 144) número → (base 26) matriz de números → (agregando 'a' a cada uno número) cadena

'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

> <> (Pez), 84 78 bytes

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

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

Pruébalo en línea!

Comenzamos a nadar desde la esquina superior izquierda, hacia la derecha. Primero cargamos la pila con un 0. Luego leemos la primera letra de entrada ( i), la descartamos (~ ), leemos la segunda letra ( i) y reducimos su valor ASCII módulo 10 (a% ). Esto asigna a, e, r, l, g y t a 7, 1, 4, 8, 3 y 6, respectivamente. Llamemos a este número N. .saca dos valores de la pila, N y 0, y salta a línea N, caracter 0.

Después de un salto, el pez continúa un tic antes de ejecutar las instrucciones, por lo que ignora el primer carácter y nada a través de la línea N, que carga la palabra correspondiente en la pila. Finalmente, vamos a la línea 2, que genera la pila completa y sale.

• Ahorré seis bytes usando un salto, en lugar de la auto-modificación del código genial que usé antes. Oh bien.

JavaScript, 78 bytes

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

Este es un tipo de puerto de mi respuesta de Python . Almacenamos las palabras en una cadena donde cada una está en la posición opuesta a su contraparte. Encontramos el índice de la palabra dadaw , y obtenemos ese índice desde el final, para devolver el resultado.

Fragmento de prueba:

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"))

Pari / GP, 86 Byte

Pari / GP es un intérprete interactivo, no necesitamos un "print" -cmd para la salida; sin embargo, la utilidad Try-It_Online necesita una "impresión" -cmd, así que separé esto al "pie de página".
Definimos una "función de objeto" (la letra O me recuerda encantadora de la función de Orwell ... ;-)):

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

Después de eso, llama

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

Pruébalo en línea!

(¡Tenga en cuenta que en Pari / GP los tokens dados aquí no son cadenas sino nombres de variables legales! A esas variables nunca se les debe asignar ningún valor)

Apilado, 70 bytes

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

Pruébalo aquí! Toma la entrada en la pila y deja la salida en la pila. Por ejemplo:

'war'

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

out

Este código es bastante autoexplicativo. Ligeramente modificado para ejecutar todos los casos de prueba:

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

Jolf, 35 bytes

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

Hay muchos no imprimibles. Aquí hay un hexdump, aunque no servirá de mucho:

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

Aquí hay un enlace en línea.

Básicamente, el código se ve así:

.γ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 realidad , 56 bytes

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

Pruébalo en línea!

Desafortunadamente, sin ninguna compresión incorporada, es más corto no comprimir la cadena y descomprimirla manualmente.

Explicación:

' "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 bytes

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

Idea:

• Enumere las palabras clave de modo que su contraparte esté a 3 posiciones de distancia
• Tome la palabra clave, obtenga su posición por fromEnum , mueva 3 pasos hacia la derecha (módulo 6) y vuelva a convertir a la palabra clave
• El ::Oes necesario porque la inferencia de tipos tiene algunos problemas. Dar funa firma f :: O -> Otendría el mismo efecto pero no es tan corto.

Editar:

Reemplazado

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

por

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

Gracias a @Laikoni.

Dyalog APL , 66 bytes

Cualquiera de estos:

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞utiliza este método (requiere ⎕IO←0el predeterminado en muchos sistemas).

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ realiza una búsqueda, luego selecciona el elemento correspondiente de la lista invertida.

Qbasic, 138 99 bytes

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

D$almacena todas las palabras del lado izquierdo del mantra, luego todas las del lado derecho. Cada palabra se rellena con espacios para exactamente 9 letras por palabra. D$luego se adjunta a sí mismo.

Luego instrse utiliza para encontrar el índice de la palabra ingresada por el usuario. La otra parte del mantra siempre se almacena exactamente 9 * 3 posiciones más adelante en la cadena, por lo que imprimimos una subcadena que comienza en esa posición, tomando 9 caracteres.

SmileBASIC, 92 bytes

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

Python , 80 bytes

De alguna manera superó a xnor!

Esta es una función lambda sin nombre, que devuelve el resultado.

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

Pruébalo en línea!

La lista de palabras está organizada de tal manera que cada una está en la posición opuesta a su contraparte. Dada la palabra w, encontramos su índice en la lista de palabras, y luego NO a nivel bit ( ~). Esto voltea todos los bits, que se calcula n => -n-1. Debido a la indexación negativa de Python, obtiene el índice opuesto en la lista.

Como una especie de bonificación no intencional, puede pasar cualquier lista de palabras de opuestos a esta función como segundo argumento.