Haftungsausschluss: Dies ist nicht meine Herausforderung, aber ThisGuy sagte, ich sei in Ordnung zu posten.

Gelegentlich möchte ich ein Wort in das Gegenteil bringen, wie es bei happinessgeht unhappiness. Leider geht mein Gehirn in diesem Fall manchmal leer aus. Dann, eines Tages nach dem anderen, dachte ich mir: "Dafür sind Programme da!"

Da die englische Sprache viele Ausnahmen hat, habe ich eine Liste erstellt, die das Präfix für den Anfangsbuchstaben enthält

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)

Aufgabe

Bei einer Eingabe als Zeichenfolge machen Sie die Zeichenfolge zu ihrem Negativ und geben das Ergebnis aus. Sie können davon ausgehen, dass alle angegebenen Eingaben den obigen Regeln entsprechen. Einsendungen können Programme oder Funktionen sein, keine Schnipsel.

Eingang

Eine einzelne Zeichenfolge, die entweder als Parameter oder aus STDIN übernommen wird

Ausgabe

Die negierte Form dieser Zeichenfolge, die den obigen Regeln entspricht

Wie gewinnt man

Dies ist ein Code-Golf, also gewinnt der kürzeste Code

Python, 55 Bytes

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

Probieren Sie es online!

Wir müssen 7 verschiedene Anfangsbuchstaben behandeln:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> irund alles andere ->un

Wir können alle diese Negationen in einer einzigen Zeichenfolge speichern und die richtige durch Schneiden extrahieren:

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

'ddiiiiuiimmlrnss'[i::7]

Jetzt müssen wir den Startindex berechnen i. 'rlmphq'.findgibt 0 für 'r', 5 für qund -1 für alles zurück, was nicht in der Zeichenkette enthalten ist. Um den erforderlichen Wert von 0 auf 6 zu erhalten, müssen wir den Rückgabewert von 5 subtrahieren. Dies führt zu folgendem Code:

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

GNU sed , 50 Bytes

Beinhaltet +1 für -r

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

Nichts Besonderes. Verwendet &die Ersetzung, um einige Ersetzungen zu kombinieren und tdie letzte zu überspringen, wenn eine der ersten Ersetzungen erfolgt.

Probieren Sie es online!

Gelee , 30 Bytes

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

Probieren Sie es online!

Wie?

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

Beachten Sie, dass das wiederholte Ein rim “qmlrrhp”fünften Index steht, was, wenn es referenziert wird, zu einem Voranstellen führen würde un, sodass es genauso gut alles andere als hoder sein könnte p.

/// , 59 56 Bytes

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

Probieren Sie es online!

Die Eingabe erfolgt nach dem allerletzten #.

Wie es funktioniert:

Ich habe eine Optimierung vorgenommen, bei der die Größe auf 56 Byte reduziert wurde. Da dies jedoch die Dinge kompliziert, erkläre ich zunächst die Originalversion und dann den 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

Intuition: Die Herausforderung ist einfach genug. Fügen Sie einfach das Negative hinzu, abhängig vom Wortanfang. In /// können Sie jedoch nicht einfach concatenate if [...]nur etwas ersetzen, das einem bestimmten Muster folgt. In diesem Programm werden also die positiven Wortanfänge durch die negativen Wortanfänge ersetzt. Das #wurde hinzugefügt, um sicherzustellen, dass, sobald ein neuer Anfang hinzugefügt wurde, keine neuen Anfänge mehr hinzugefügt werden. Das #machte es auch möglich, "alles andere zu tun: un".

Der Golf verfügt über eine neue Substitution an ihn beginnt: /^/\/\/#/. Dieser ersetzt alles ^durch //#, was in der Originalversion ein gängiges Muster war.

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

Erfordert alle Großbuchstaben.

Erläuterung:

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

Bearbeitungen:

• 7 Bytes gespart dank @ErtySeidohl ( charAt(0)-> [0])
• 3 Bytes gespart dank @ edc65 (Zuweisen gemeinsamer Präfixe zu Variablen)

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

Batch, 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%

Überprüft das erste Zeichen des Wortes anhand der Liste der benutzerdefinierten Präfixe und ändert in diesem Fall das Präfix von un. Sondergehäuse qusind zum Preis von 21 Byte möglich.

Haskell, 71 Bytes

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

Anwendungsbeispiel: f "legal"-> "illegal". Probieren Sie es online!

Erstellen Sie eine Nachschlagetabelle mit Präfix- / Ersetzungspaaren, um das erste Zeichen der Eingabezeichenfolge mit dem Standardwert " "un"Wenn nicht gefunden" nachzuschlagen.

Netzhaut , 54 Bytes

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

Erläuterung:

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

Zum ersten Mal habe ich Retina verwendet. Es ist eine ziemlich ordentliche Sprache.

Probieren Sie es 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

Ja, es ist immer noch länger als eine bestehende Lösung. :)

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

Falls dies eine Erklärung erfordert, nutze ich die q / h- und m / p-Paare aus, indem ich ihren Index in der Suchzeichenfolge mit einer Modifikation 4 kombiniere und diese dann als Suche in das Präfix-Array verwende.

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

Probieren Sie es online!

Mathematica, 107 Bytes

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

Erläuterung:

StartOfString~~x:#:>#2<>x&ist eine reine Funktion, bei der das erste Argument ein Zeichenfolgenmuster ist , das am Anfang der Zeichenfolge übereinstimmt, und das zweite Argument eine Zeichenfolge ist, die der Übereinstimmung vorangestellt wird. Es wird eine verzögerte Regel zurückgegeben, die für die Verwendung innerhalb von geeignet ist StringReplace. Dies wird dann auf jedes der Paare angewendet, {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}was zu einer Liste von Regeln führt

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

Schließlich wird diese Liste übergeben, in StringReplacedie ein Operator für Zeichenfolgen eingegeben wird.

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;

Online Version

Excel 78 Bytes

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

Ich habe einige enge Konkurrenten mit verschiedenen Methoden gefunden, die 81 Bytes erreicht haben:

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

Und 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

Spart ein paar Bytes durch Antworten in GROSSBUCHSTABEN, zB potent -> IMPOTENT.

Perl, 49 + 1 ( -pFlag) = 50 Bytes

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

Verwenden von:

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

Probieren Sie es online aus .

Clojure, 65 Bytes

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

Nun, das ist langweilig ... aber ich könnte es nicht kürzer machen. Zumindest gibt es sehr wenig Leerzeichen.

OCaml, 85

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

Bei der anonymen Funktion wird die Mustererkennung beim ersten Zeichen verwendet.