Uwaga: To nie jest moje wyzwanie, ale ThisGuy powiedział, że mogę pisać .

Czasami chcę zamienić słowo w jego przeciwieństwo, jak happinessidzie do unhappiness. Niestety, kiedy to się dzieje, mój mózg czasami staje się pusty. Pewnego dnia, po kolejnym wydarzeniu, pomyślałem sobie: „Po to są programy!”.

Ponieważ język angielski ma wiele wyjątków, utworzyłem listę zawierającą prefiks litery początkowej

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)

Zadanie

Biorąc pod uwagę dane wejściowe jako ciąg znaków, należy wprowadzić ciąg znaków jako ujemny i wyprowadzić wynik. Możesz założyć, że wszystkie podane dane wejściowe będą pasować do powyższych zasad. Zgłoszenia mogą być programami lub funkcjami, a nie fragmentami.

Wejście

Pojedynczy ciąg, pobrany albo jako parametr, albo ze STDIN

Wynik

Negowana forma tego łańcucha, zgodna z powyższymi zasadami

Jak wygrać

To jest golf golfowy, więc wygrywa najkrótszy kod

Python, 55 bajtów

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

Wypróbuj online!

Musimy obsłużyć 7 różnych liter początkowych:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> iri wszystko inne ->un

Możemy przechowywać wszystkie te negacje w jednym łańcuchu i wyodrębnić właściwy poprzez krojenie:

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

'ddiiiiuiimmlrnss'[i::7]

Teraz musimy obliczyć indeks początkowy i. 'rlmphq'.findzwraca 0 dla 'r', 5 dla qi -1 dla wszystkiego, co nie jest zawarte w ciągu. Aby uzyskać potrzebną wartość od 0 do 6, nadal musimy odjąć zwracaną wartość od 5, co daje następujący kod:

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

GNU sed , 50 bajtów

Obejmuje +1 dla -r

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

Nic fajnego. Używa &w zamianie do połączenia kilku podstawień i tpominięcia ostatniego, jeśli nastąpi jedno z pierwszych zastąpień.

Wypróbuj online!

Galaretka , 30 bajtów

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

Wypróbuj online!

W jaki sposób?

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

Zauważ, że powtórzenie rin “qmlrrhp”znajduje się w piątym indeksie, który, jeśli będzie się do niego odwoływał, spowoduje dodanie un, więc równie dobrze może być czymkolwiek innym niż hlub p.

/// , 59 56 bajtów

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

Wypróbuj online!

Wejście następuje po ostatnim #.

Jak to działa:

Dokonałem optymalizacji, która zmniejszyła rozmiar do 56 bajtów, ale ponieważ to komplikuje rzeczy, wyjaśnię oryginalną wersję, a następnie wyjaśnię golfa.

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

Intuicja: Wyzwanie jest dość proste, wystarczy dodać przeczenie w zależności od początku słowa. Jednak w /// nie możesz po prostu concatenate if [...]zastąpić czegoś według określonego wzorca. W tym programie początkowe słowa dodatnie są zastępowane początkowymi słowami ujemnymi. Zostało #to dodane, aby upewnić się, że po dodaniu nowego początku nie będą dodawane żadne nowe początki. #Również można zrobić „wszystko inne: UN”.

Pole zawiera nową podstawienie on na początku: /^/\/\/#/. Zastępuje to wszystko ^z //#, który był wspólny wzór w wersji oryginalnej.

TI-Basic, 104 bajty

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

Wymaga wszystkich wielkich liter.

Wyjaśnienie:

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 bajtów)

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

Edycje:

• Zaoszczędź 7 bajtów dzięki @ErtySeidohl ( charAt(0)-> [0])
• Zapisano 3 bajty dzięki @ edc65 (przypisywanie wspólnych prefiksów do zmiennych)

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

Partia, 114 bajtów

@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%

Sprawdza pierwszy znak słowa na liście niestandardowych prefiksów, a jeśli tak, zmienia prefiks na domyślny un. quMożliwa jest specjalna obudowa w cenie 21 bajtów.

Haskell, 71 bajtów

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

Przykład użycia: f "legal"->"illegal" . Wypróbuj online!

Zbuduj tabelę wyszukiwania par prefiks / zamiennik, aby wyszukać pierwszy znak ciągu wejściowego z wartością domyślną, "un"jeśli nie zostanie znaleziony.

Siatkówka , 54 bajty

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

Wyjaśnienie:

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

Pierwszy raz użyłem Retiny. To całkiem fajny język.

Wypróbuj online!

JavaScript, 72 71 66 61 60 59 bajtów

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

Tak, to wciąż dłużej niż istniejące rozwiązanie. :)

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

W przypadku, gdy wymaga to wyjaśnienia, korzystam z par q / hi m / p, łącząc ich indeks w ciągu wyszukiwania z mod 4, a następnie wykorzystując to jako odnośnik do tablicy prefiksów.

C, 109 107 bajtów

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

Wypróbuj online!

Mathematica, 107 bajtów

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

Wyjaśnienie:

StartOfString~~x:#:>#2<>x&to czysta funkcja, w której pierwszy argument jest ciągiem znaków, który ma zostać dopasowany na początku ciągu, a drugi argumentem jest ciągiem znaków, który należy dołączyć do dopasowania. Zwraca opóźnioną regułę odpowiednią do użycia wewnątrz StringReplace. Jest to następnie stosowane do każdej pary, w {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}wyniku czego powstaje lista reguł

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

Na koniec przekazywana jest ta lista, StringReplacektóra daje operatorowi ciągów znaków.

PHP, 101 bajtów

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

Wersja online

Excel 78 bajtów

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

Znalazłem kilku bliskich konkurentów przy użyciu różnych metod, które uzyskały 81 bajtów:

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

I 84 bajty:

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

REXX, 78 bajtów

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

Zapisuje kilka bajtów, odpowiadając w DUŻYM LICZBIE, np. Silny -> IMPOTENT.

Perl, 49 + 1 ( -pflaga) = 50 bajtów

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

Za pomocą:

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

Wypróbuj online .

Clojure, 65 bajtów

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

Cóż, to jest nudne ... ale nie mogłem go skrócić. Przynajmniej jest bardzo mało białych znaków.

OCaml, 85

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

Funkcja anonimowa, używa dopasowania wzorca do pierwszego znaku.