La guerra es paz. Libertad es esclavitud. Ignorancia es fuerza

69

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.

Pasatiempos de Calvin
fuente
10
Relacionado :-)
xnor
2
@ Dennis Sí. O todo está en minúsculas o todo en mayúsculas.
Calvin's Hobbies
3
No sé si alguien puede usar esto para comprimir más sus cadenas (no mejoró mi puntaje en Pip), pero las letras iniciales de estas palabras ( w p f s i) no se encuentran en ninguna otra parte de las palabras. Una propiedad intrigante.
DLosc
13
Este es un desafío doble plusgood
Jojodmo
3
A casi nadie le gusta este libro. ¡Está lleno de mentiras! Triste.
Peter - Restablece a Mónica el

Respuestas:

58

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
Emigna
fuente
42
14 bytes más cortos que la longitud de todas las palabras. ¿Qué es este idioma?
DJMcMayhem
65
> Empuje la cuerdaignorance strength war peace freedom slavery ¡Siento que me faltan unos doce pasos!
Bob
10
¿Alguien puede explicar de dónde viene el resto de las palabras además de "ignorancia"?
Carcigenicate
36
05AB1E tiene un diccionario incorporado de palabras que están representadas por 2 bytes cada una: github.com/Adriandmen/05AB1E/blob/master/dictionary.py
Robert Fraser
47

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

Arnauld
fuente
2
Ese es un enfoque genial. Nunca hubiera pensado en eso.
Carcigenicate
Muy agradable. Los restantes no son distintos para 6, 7, 8, por lo que necesita 9.
ShreevatsaR
¿Usa un separador como zy luego comprime la cadena con atobahorra 8 bytes?
Downgoat
@Downgoat ¿No requeriría mucho escape para personajes fuera del rango 32-126?
Arnauld
al usar atob, obtienes una cadena que es en su mayoría javascript válido; eventualmente solo necesitas escapar de la `\ 'y la cita de cierre. Puede ser difícil publicarlo en este sitio, pero eso no invalida la respuesta. Ver la respuesta perl por smis
edc65
32

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.

Dennis
fuente
16

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.

Martin Ender
fuente
Argh, muy bien hecho! Pierdo por 7 bytes con WordList[][[<|"l"->14007,"t"->17083,"a"->25105,"r"->32106,"g"->33790,"e"->39048|>@#[[2]]]]&.
Greg Martin el
@ GregMartin Oh, WordListestá bien. Sin embargo, tomar una lista de caracteres como entrada y devolver una cadena parece un poco dudoso. ;) Dicho esto, puedes hacer 4 bytes mejor con x[[7-Position[x={"war","slavery","ignorance","strength","freedom","peace"},#][[1,1]]]]&.
Martin Ender
Estaré interesado en tu opinión, pero para mí, parece dudoso aprobado por PP y CG :)
Greg Martin
también <|#->#2&~MapThread~{x={"war","slavery","ignorance","strength","fre‌edom","peace"},Reverse@x}|>para 94 bytes
Greg Martin
13

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
DJMcMayhem
fuente
10

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!

Dennis
fuente
8

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
xnor
fuente
¿Se permiten definiciones de variables fuera de lamba cuando se usa una lambda en lugar de un programa completo?
sonríe el
1
@smls Sí, vea esta meta discusión . Tenga en cuenta que, de lo contrario, uno podría pasar de contrabando lcomo argumento opcional.
xnor
8

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.
    ]
}
smls
fuente
8

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.

Mitchell Spector
fuente
8

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
Timtech
fuente
7

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)

Dada
fuente
6

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)])
MickyT
fuente
5

PHP, 70 bytes

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

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

Código fuente con rutas de ejecución resaltadas

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

James Holderness
fuente
2
Me gusta el uso de :-<y @>:#"emoticonos" aquí :)
Tobias Kienzler
5

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[^]
Azul
fuente
5

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]
edc65
fuente
4

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!

Dennis
fuente
4

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

edc65
fuente
3

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
aditsu
fuente
3

> <> (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.
Nick Matteo
fuente
3

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

FlipTack
fuente
2

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)

Yelmos de Gottfried
fuente
2

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
Conor O'Brien
fuente
1
¿qué 'LFhacer?
Downgoat
1
@Downgoat Bueno, @xestablece una variable, '...'es una cadena y LFes la variable de salto de línea
Conor O'Brien el
1
Ah, ya veo, ¿entonces el argumento de la función viene antes del nombre de la función?
Downgoat
1
@Downgoat Precisamente. Apilado es, bueno, basado en pila.
Conor O'Brien el
1
yay ahora me siento tonto por no darme cuenta de un hecho tan obvio: |
Downgoat
2

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
Conor O'Brien
fuente
2

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
Mego
fuente
2

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.

usuario3389669
fuente
2
Usar notación de punto completo para fes más corto:f s=toEnum$mod(3+fromEnum s)6
Laikoni
2

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.

Adám
fuente
2

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.

Steenbergh
fuente
2

SmileBASIC, 92 bytes

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

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.

FlipTack
fuente