Disclaimer: Este não é o meu desafio, mas ThisGuy disse que eu estava bem em postar.

Ocasionalmente, quero escrever uma palavra sobre o oposto, como happinessvai para unhappiness. Infelizmente, quando isso acontece, meu cérebro às vezes fica em branco. Então, um dia, depois de mais um acontecimento, pensei: "É para isso que servem os programas!"

Como o idioma inglês possui muitas exceções, criei uma lista que contém o prefixo da 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)

Tarefa

Dada uma entrada como uma sequência, faça com que a sequência seja negativa e produza o resultado. Você pode assumir que todas as entradas fornecidas se ajustarão às regras acima. Os envios podem ser programas ou funções, não trechos.

Entrada

Uma única sequência, tomada como parâmetro ou em STDIN

Resultado

A forma negada dessa sequência, em conformidade com as regras acima

Como ganhar

Este é um código de golfe, então o código mais curto ganha

Python, 55 bytes

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

Experimente online!

Precisamos lidar com 7 letras iniciais diferentes:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> ire tudo mais ->un

Podemos armazenar todas essas negações em uma única sequência e extrair a correta através do corte:

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

'ddiiiiuiimmlrnss'[i::7]

Agora precisamos calcular o índice inicial i. 'rlmphq'.findretorna 0 para 'r', 5 para qe -1 para tudo que não está contido na string. Para obter o valor necessário de 0 a 6, ainda precisamos subtrair o valor de retorno de 5, resultando neste código:

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

GNU sed , 50 bytes

Inclui +1 para -r

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

Nada chique. Usa &na substituição para combinar algumas substituições e tpular a última se uma das primeiras substituições ocorrer.

Experimente online!

Gelatina , 30 bytes

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

Experimente online!

Quão?

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

Observe que a repetição rde entrada “qmlrrhp”está no 5º índice, que, se referenciado, resultaria em prefixação un, portanto, poderia igualmente ser algo diferente de hou p.

/// , 59 56 bytes

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

Experimente online!

A entrada ocorre depois da última #.

Como funciona:

Fiz uma otimização que reduziu o tamanho para 56 bytes, mas como isso complica, explicarei a versão original e depois explicarei o golfe.

/#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

Intuição: o desafio é bastante simples, basta adicionar o negativo, dependendo do início da palavra. No entanto, em ///, você não pode apenas concatenate if [...], só pode substituir algo seguindo um padrão específico. Portanto, neste programa, as palavras positivas no início são substituídas pelas palavras negativas no início. O #foi adicionado para se certificar de que uma vez que um novo começo foi adicionado, seria adicionado não mais novos começos. O #também tornou possível fazer 'tudo o resto: un'.

O golf incorpora uma nova substituição no que ele começando: /^/\/\/#/. Isso substitui tudo ^por //#, que era um padrão comum na versão original.

TI-Básico, 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

Requer todas as letras maiúsculas.

Explicação:

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

Editar% s:

• Guardado 7 bytes graças a @ErtySeidohl ( charAt(0)-> [0])
• Economizou 3 bytes graças a @ edc65 (atribuindo prefixos compartilhados a variáveis)

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%

Verifica o primeiro caractere da palavra na lista de prefixos personalizados e, se houver, altera o prefixo do padrão de un. Caixa especial qué possível a um custo de 21 bytes.

Haskell, 71 bytes

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

Exemplo de uso: f "legal"-> "illegal". Experimente online!

Crie uma tabela de consulta de pares de prefixo / substituição para procurar o primeiro caractere da sequência de entrada com um valor padrão "un"se não for encontrado.

Retina , 54 bytes

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

Explicação:

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

Primeira vez que usei Retina. É uma linguagem bem legal.

Experimente online!

Javascript, 72 71 66. 61 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

Sim, ainda é mais do que uma solução existente. :)

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

Caso isso precise de alguma explicação, estou aproveitando os pares q / he m / p combinando seu índice na cadeia de pesquisa com um mod 4 e, em seguida, usando isso como pesquisa na matriz de prefixos.

C, 109 107 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);}

Experimente online!

Mathematica, 107 bytes

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

Explicação:

StartOfString~~x:#:>#2<>x&é uma função pura em que o primeiro argumento é um padrão de sequência a ser correspondido no início da sequência e o segundo argumento é uma sequência a ser anexada à correspondência. Retorna uma regra atrasada, adequada para uso interno StringReplace. Isso é aplicado a cada um dos pares, {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}resultando na lista de regras

{
  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, esta lista é passada para a StringReplacequal fornece um operador em strings.

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;

Versão Online

Excel 78 bytes

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

Encontrei alguns candidatos próximos usando métodos diferentes que tiveram 81 bytes:

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

E 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

Economiza alguns bytes, respondendo em MAIÚSCULAS, por exemplo, potente -> IMPOTENT.

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

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

Usando:

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

Experimente online .

Clojure, 65 bytes

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

Bem, isso é chato ... mas eu não poderia torná-lo mais curto. Pelo menos, há muito pouco espaço em branco.

OCaml, 85

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

Função anônima, usa correspondência de padrão em seu primeiro caractere.