Descargo de responsabilidad: este no es mi desafío, pero ThisGuy dijo que estaba bien publicar.

De vez en cuando quiero hacer una palabra en su opuesto, como happinessva a unhappiness. Desafortunadamente, cuando esto sucede, mi cerebro a veces se queda en blanco. Entonces, un día, después de que esto sucediera, pensé: "¡Para eso están los programas!"

Como el idioma inglés tiene muchas excepciones, he creado una lista que contiene el prefijo para la letra inicial

q or h          -> dis- (honest -> dishonest)
l                -> il-  (legal -> illegal)
m or p           -> im-  (mature -> immature)
r                -> ir-  (responsible -> irresponsible)
everything else  -> un-  (worthy -> unworthy)

Tarea

Dada una entrada como una cadena, haga que la cadena sea negativa y genere el resultado. Puede suponer que todas las entradas dadas se ajustarán a las reglas anteriores. Los envíos pueden ser programas o funciones, no fragmentos.

Entrada

Una sola cadena, tomada como parámetro o desde STDIN

Salida

La forma negada de esa cadena, conforme a las reglas anteriores.

Cómo ganar

Este es un código de golf, por lo que el código más corto gana

Python, 55 bytes

lambda n:'ddiiiiuiimmlrnss'[5-'rlmphq'.find(n[0])::7]+n

Pruébalo en línea!

Necesitamos manejar 7 letras iniciales diferentes:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> iry todo lo demás ->un

Podemos almacenar todas estas negaciones en una sola cadena y extraer la correcta mediante el corte:

 d      i      s
  d      i      s
   i      m
    i      m
     i      l
      i      r
       u      n

'ddiiiiuiimmlrnss'[i::7]

Ahora necesitamos calcular el índice de inicio i. 'rlmphq'.finddevuelve 0 para 'r', 5 para qy -1 para todo lo que no está contenido en la cadena. Para obtener el valor necesario de 0 a 6, aún necesitamos restar el valor de retorno de 5, lo que da como resultado este código:

'ddiiiiuiimmlrnss'[5-'rlmphq'.find(n[0])::7]

GNU sed , 50 bytes

Incluye +1 para -r

s/^q|^h/dis&/
s/^l|^r|^m/i&&/
s/^p/imp/
t
s/^/un/

Nada sofisticado. Utiliza &el reemplazo para combinar algunas sustituciones y tomitir el último si ocurre una de las primeras sustituciones.

Pruébalo en línea!

Jalea , 30 bytes

1ị“qmlrrhp”iị“3bµWI⁼ṡ÷ʠ$»œs5¤;

Pruébalo en línea!

¿Cómo?

1ị“qmlrrhp”iị“3bµWI⁼ṡ÷ʠ$»œs5¤; - Main link: string
1ị                             - 1 index into the string (first character of the string)
           i                   - 1-based index of 1st occurrence of that in (else zero):
  “qmlrrhp”                    -     char list "qmlrrhp"
            ị                  - index into (1-based and modulo):
                            ¤  -     nilad followed by link(s) as a nilad:
             “3bµWI⁼ṡ÷ʠ$»      -         compressed string "dis"+"imili"+"run"="disimilirun"
                         œs5   -         split "equally" into 5: ["dis","im","il","ir","un"]
                             ; - concatenate with the string

Tenga en cuenta que la repetición ren “qmlrrhp”está en el quinto índice, que, si se hace referencia, daría lugar a anteponer un, por lo que podría ser cualquier otra cosa que no sea ho p.

/// , 59 56 bytes

/^/\/\/#//#qu/disqu^h/dish^l/ill^m/imm^p/ipp^r/irr^/un/#

Pruébalo en línea!

La entrada va después del último #.

Cómo funciona:

Hice una optimización que redujo el tamaño a 56 bytes, pero como eso complica las cosas, explicaré la versión original y luego explicaré el golf.

/#qu/disqu//#h/dish//#l/ill//#m/imm//#p/ipp//#r/irr//#/un/# |everything after the ` |` is not code.
/#qu/disqu/                                                 |replace `qu` with `disqu`
           /#h/dish/                                        |replace `h` with `dish`.
                    /#l/ill/                                |replace `l` with `ill`.
                            /#m/imm/                        |replace `m` with `imm`.
                                    /#p/ipp/                |replace `p` with `ipp`.
                                            /#r/irr/        |replace `r` with `irr`.
                                                    /#/un/  |replace everything else with `un`.
                                                          # |safety control

Intuición: el desafío es bastante simple, solo agregue lo negativo dependiendo del comienzo de la palabra. Sin embargo, en ///, no puede simplemente concatenate if [...], solo puede reemplazar algo siguiendo un patrón específico. Entonces, en este programa, los comienzos de palabras positivas se reemplazan por los comienzos de palabras negativas. Se #agregó para asegurarse de que una vez que se agregó un nuevo comienzo, no se agregarán más nuevos comienzos. El #también hizo posible hacer 'todo lo demás: un'.

El campo incorpora una nueva sustitución en la que comienza: /^/\/\/#/. Esto reemplaza todo ^con //#, que era un patrón común en la versión original.

TI-Basic, 104 bytes

Prompt Str0
sub(Str0,1,1→Str2
Str0
If Str2="Q" or Str2="H
"DIS"+Ans
If Str2="L
"IL"+Ans
If Str2="M" or Str2="P
"IM"+Ans
If Str2="R
"IR"+Ans
If Ans=Str0
"UN"+Ans
Ans

Requiere todas las letras mayúsculas.

Explicación:

Prompt Str0             # 4 bytes, input user string to Str0
sub(Str0,1,1→Str2       # 12 bytes, store first character in Str2
Str0                    # 3 bytes, store Str0 in Ans
If Str2="Q" or Str2="H  # 14 bytes, if the first letter was Q or H
"DIS"+Ans               # 8 bytes, store DIS+Ans in Ans
If Str2="L              # 7 bytes, If the first letter was L
"IL"+Ans                # 7 bytes, store IL+Ans in Ans
If Str2="Q" or Str2="H  # 14 bytes, if the first letter was Q or H
"IM"+Ans                # 7 bytes, store DIS+Ans in Ans
If Str2="R              # 7 bytes, if the first letter was R
"IR"+Ans                # 7 bytes, store IR+Ans in Ans
If Ans=Str0             # 6 bytes, if Ans has not been changed (first letter was none of the above)
"UN"+Ans                # 7 bytes, store UN+Ans in Ans
Ans                     # 1 byte, implicitly return Ans

JavaScript ( 71 64 61 bytes)

w=>({q:a='dis',h:a,l:'il',m:b='im',p:b,r:'ir'}[w[0]]||'un')+w

Ediciones:

• Guardado 7 bytes gracias a @ErtySeidohl ( charAt(0)-> [0])
• Guardado 3 bytes gracias a @ edc65 (asignando prefijos compartidos a variables)

var f = w=>({q:a='dis',h:a,l:'il',m:b='im',p:b,r:'ir'}[w[0]]||'un')+w;

function onChange() {
   var word = event.target.value;
   var output = f(word);
   document.getElementById('output').innerHTML = output;
}

Input Word: <input type='text' oninput='onChange()'/><br/>
Output Word: <span id="output">

Lote, 114 bytes

@set/pw=
@set p=un
@for %%p in (dis.q dis.h il.l im.m im.p ir.r)do @if .%w:~,1%==%%~xp set p=%%~np
@echo %p%%w%

Comprueba el primer carácter de la palabra con la lista de prefijos personalizados y, de ser así, cambia el prefijo del valor predeterminado de un. La carcasa especial ques posible a un costo de 21 bytes.

Haskell, 71 bytes

f l=maybe"un"id(lookup(l!!0)$zip"qhlmpr"$words"dis dis il im im ir")++l

Ejemplo de uso: f "legal"-> "illegal". Pruébalo en línea!

Cree una tabla de búsqueda de pares de prefijo / reemplazo para buscar el primer carácter de la cadena de entrada con un valor predeterminado de "un"si no se encuentra.

Retina , 54 bytes

^[^hqlmpr]
un$+
^[hq]
dis$+
^l
il$+
^[mp]
im$+
^r
ir$+

Explicación:

             {implicit replace stage}
^[^hqlmpr]   Append un to words starting with none of: hqlmpr
un$+         
^[hq]        Append dis to words starting with h or q
dis$+        
 ^l          Append il to words starting with l
il$+          
^[mp]        Append il to words starting with m or p
im$+    
^r           Append ir to words starting with r
ir$+

Primera vez que uso Retina. Es un lenguaje bastante bueno.

Pruébalo en línea!

Javascript, 72 71 66 61 60 60 59 bytes

w=>('dis....il.im...im.dis.ir'.split('.')[w.charCodeAt(0)-104]||'un')+w

w=>'un.dis.dis.il.im.im.ir'.split('.')['qhlmpr'.indexOf(w[0])+1]+w

Sí, todavía es más largo que una solución existente. :)

w=>['un','dis','im','il','ir']['qmlrhp'.search(w[0])%4+1]+w

En caso de que esto necesite alguna explicación, estoy aprovechando los pares q / hym / p combinando su índice en la cadena de búsqueda con un mod 4, y luego lo uso como búsqueda en la matriz de prefijos.

C, 109107 bytes

f(char*s){printf("%s%s",*s-109&&*s-112?*s-108?*s-114?*s-104&&*s-113|s[1]-117?"un":"dis":"ir":"il":"im",s);}

Pruébalo en línea!

Mathematica, 107 bytes

StringReplace[StartOfString~~x:#:>#2<>x&@@@{{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}]

Explicación:

StartOfString~~x:#:>#2<>x&es una función pura donde el primer argumento es un patrón de cadena que debe coincidir al comienzo de la cadena y el segundo argumento es una cadena que antecede a la coincidencia. Devuelve una regla retrasada adecuada para su uso dentro StringReplace. Esto se aplica a cada uno de los pares que {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}dan como resultado la lista de reglas

{
  StartOfString~~x:"q"|"h":>"dis"<>x,
  StartOfString~~x:"l":>"il"<>x,
  StartOfString~~x:"m"|"p":>"im"<>x,
  StartOfString~~x:"r":>"ir"<>x,
  StartOfString~~x_:>"un"<>x
}

Finalmente, se pasa esta lista StringReplaceque proporciona un operador en cadenas.

PHP, 101 bytes

echo preg_match("#^(qu|[hlmpr])#",$argn,$t)?[qu=>dis,h=>dis,l=>il,m=>im,p=>im,r=>ir][$t[1]]:un,$argn;

Versión en línea

Excel 78 bytes

=TRIM(MID("  disdisil im im ir un",IFERROR(FIND(LEFT(A1),"qhlmpr"),7)*3,3))&A1

Encontré algunos contendientes cercanos usando diferentes métodos que obtuvieron 81 bytes:

=IFERROR(CHOOSE(FIND(LEFT(A1),"qhlmpr"),"dis","dis","il","im","im","ir"),"un")&A1

Y 84 bytes:

=IFERROR(TRIM(MID("im disi"&LEFT(A1),MOD(FIND(LEFT(F1),"qlmhrp"),3)*3+1,3)),"un")&A1

REXX, 78 bytes

arg a
s.=un
s.q=dis
s.h=s.q
s.l=il
s.m=im
s.p=im
s.r=ir
p=left(a,1)
say s.p||a

Ahorra algunos bytes respondiendo en MAYÚSCULAS, por ejemplo, potente -> IMPOTENTE.

Perl, 49 + 1 ( -pbandera) = 50 bytes

s|^[hq]|dis$&|||s|^[lmr]|i$&$&|||s|p|imp|||s||un|

Utilizando:

perl -pe 's|^[hq]|dis$&|||s|^[lmr]|i$&$&|||s|p|imp|||s||un|' <<< responsible

Pruébalo en línea .

Clojure, 65 bytes

#(str(get{\q"dis"\h"dis"\l"il"\m"im"\p"im"\r"ir"}(first %)"un")%)

Bueno, esto es aburrido ... pero no podría hacerlo más corto. Al menos hay muy poco espacio en blanco.

OCaml, 85

(fun s->(match s.[0]with|'q'|'h'->"dis"|'l'->"il"|'m'|'p'->"im"|'r'->"ir"|_->"un")^s)

Función anónima, utiliza la coincidencia de patrones en su primer carácter.