Disclaimer: questa non è la mia sfida, ma ThisGuy ha detto che ero d' accordo a pubblicare.

Occasionalmente voglio fare una parola nel suo contrario, come happinessva unhappiness. Sfortunatamente quando ciò accade, il mio cervello a volte si svuota. Poi un giorno, dopo l'ennesima volta che questo è accaduto, ho pensato a me stesso "Questo è ciò che i programmi servono!"

Poiché la lingua inglese ha molte eccezioni, ho creato un elenco che contiene il prefisso per la lettera iniziale

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)

Compito

Dato un input come stringa, trasforma la stringa in negativo e genera il risultato. Si può presumere che tutti gli input forniti corrispondano alle regole precedenti. Gli invii possono essere programmi o funzioni, non frammenti.

Ingresso

Una singola stringa, presa come parametro o da STDIN

Produzione

La forma negata di quella stringa, conforme alle regole precedenti

Come vincere

Questo è un code-golf quindi vince il codice più breve

Python, 55 byte

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

Provalo online!

Dobbiamo gestire 7 diverse lettere iniziali:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> ire tutto il resto ->un

Siamo in grado di memorizzare tutte queste negazioni in una singola stringa ed estrarre quella giusta attraverso il taglio:

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

'ddiiiiuiimmlrnss'[i::7]

Ora dobbiamo calcolare l'indice di partenza i. 'rlmphq'.findrestituisce 0 per 'r', 5 per qe -1 per tutto ciò che non è contenuto nella stringa. Per ottenere il valore necessario da 0 a 6, dobbiamo ancora sottrarre il valore restituito da 5, ottenendo questo codice:

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

GNU sed , 50 byte

Include +1 per -r

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

Nulla di bello. Utilizza &la sostituzione per combinare alcune sostituzioni e tper saltare l'ultima se si verifica una delle prime sostituzioni.

Provalo online!

Gelatina , 30 byte

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

Provalo online!

Come?

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

Si noti che il ripetuto rin si “qmlrrhp”trova nel 5 ° indice, che, se referenziato, comporterebbe una preposizione un, quindi potrebbe anche essere qualcosa di diverso da ho p.

/// , 59 56 byte

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

Provalo online!

L'ingresso segue l'ultimo #.

Come funziona:

Ho fatto un'ottimizzazione che ha ridotto la dimensione a 56 byte, ma poiché ciò complica le cose spiegherò la versione originale, quindi spiegherò il 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

Intuizione: la sfida è abbastanza semplice, basta aggiungere il negativo a seconda dell'inizio della parola. Tuttavia, in ///, non puoi semplicemente concatenate if [...], puoi solo sostituire qualcosa seguendo uno schema specifico. Pertanto, in questo programma, le parole iniziali positive vengono sostituite con le parole negative iniziale. È #stato aggiunto per assicurarsi che una volta aggiunto un nuovo inizio, non sarebbero stati aggiunti altri nuovi inizi. Ciò ha #anche permesso di fare "tutto il resto: un".

Il campo da incorpora una nuova sostituzione in lui inizio: /^/\/\/#/. Questo sostituisce tutto ^con //#, che era un modello comune nella versione originale.

TI-Basic, 104 byte

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

Richiede tutte le lettere maiuscole.

Spiegazione:

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

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

modifiche:

• Salvato 7 byte grazie a @ErtySeidohl ( charAt(0)-> [0])
• Salvati 3 byte grazie a @ edc65 (assegnando prefissi condivisi alle variabili)

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

Lotto, 114 byte

@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 il primo carattere della parola rispetto all'elenco dei prefissi personalizzati e, in tal caso, modifica il prefisso dal valore predefinito di un. L'involucro speciale què possibile al costo di 21 byte.

Haskell, 71 byte

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

Esempio di utilizzo: f "legal"-> "illegal". Provalo online!

Crea una tabella di ricerca di coppie prefisso / sostituzione per cercare il primo carattere della stringa di input con un valore predefinito "un"se non trovato.

Retina , 54 byte

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

Spiegazione:

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

La prima volta che ho usato Retina. È un linguaggio abbastanza pulito.

Provalo online!

Javascript, 72 71 66 61 60 59 byte

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ì, è ancora più lungo di una soluzione esistente. :)

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

Nel caso ciò necessiti di una spiegazione, sto sfruttando le coppie q / h e m / p combinando il loro indice nella stringa di ricerca con una mod 4, quindi utilizzandolo come ricerca nell'array prefisso.

C, 109 107 byte

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

Provalo online!

Mathematica, 107 byte

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

Spiegazione:

StartOfString~~x:#:>#2<>x&è una funzione pura in cui il primo argomento è un modello di stringa da abbinare all'inizio della stringa e il secondo argomento è una stringa da anteporre alla corrispondenza. Restituisce una regola ritardata adatta per l'uso all'interno StringReplace. Questo viene quindi applicato a ciascuna delle coppie {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}risultanti nell'elenco di regole

{
  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
}

Infine viene passato questo elenco in StringReplacecui viene fornito un operatore sulle stringhe.

PHP, 101 byte

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

Versione online

Excel 78 byte

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

Ho trovato alcuni contendenti vicini usando diversi metodi che hanno segnato 81 byte:

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

E 84 byte:

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

REXX, 78 byte

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

Salva alcuni byte rispondendo in MAIUSCOLO, ad es. Potente -> IMPOTENTE.

Perl, 49 + 1 ( -pflag) = 50 byte

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

Provalo online .

Clojure, 65 byte

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

Beh, questo è noioso ... ma non potrei farlo più breve. Almeno c'è pochissimo spazio bianco.

OCaml, 85

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

Funzione anonima, utilizza la corrispondenza del modello sul suo primo carattere.