Penafian: Ini bukan tantangan saya tetapi ThisGuy mengatakan saya baik-baik saja untuk mengirim.

Kadang-kadang saya ingin membuat kata menjadi kebalikannya, seperti happinesspergi ke unhappiness. Sayangnya ketika ini terjadi, otak saya terkadang menjadi kosong. Kemudian suatu hari, setelah kejadian ini terjadi lagi, saya berpikir dalam hati, "Ini untuk program apa!"

Karena bahasa Inggris memiliki banyak pengecualian, saya telah membuat daftar yang berisi awalan untuk huruf awal

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)

Tugas

Diberikan input sebagai string, buat string menjadi negatif dan hasilkan hasilnya. Anda dapat mengasumsikan bahwa semua input yang diberikan sesuai dengan aturan di atas. Kiriman dapat berupa program atau fungsi, bukan cuplikan.

Memasukkan

Satu string, diambil sebagai parameter atau dari STDIN

Keluaran

Bentuk string yang dinegasikan, sesuai dengan aturan di atas

Bagaimana cara Menang

Ini adalah kode-golf sehingga kode terpendek menang

Python, 55 byte

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

Cobalah online!

Kita perlu menangani 7 huruf awal yang berbeda:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> irdan yang lainnya ->un

Kita dapat menyimpan semua negasi ini dalam satu string dan mengekstrak yang benar melalui pengiris:

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

'ddiiiiuiimmlrnss'[i::7]

Sekarang kita perlu menghitung indeks awal i. 'rlmphq'.findmengembalikan 0 untuk 'r', 5 untuk qdan -1 untuk semua yang tidak ada dalam string. Untuk mendapatkan nilai yang dibutuhkan dari 0 hingga 6 kita masih perlu mengurangi nilai kembali dari 5, menghasilkan kode ini:

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

GNU sed , 50 byte

Termasuk +1 untuk -r

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

Tidak ada yang mewah. Gunakan &pengganti untuk menggabungkan beberapa penggantian, dan tuntuk melewatkan yang terakhir jika salah satu dari penggantian pertama terjadi.

Cobalah online!

Jelly , 30 byte

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

Cobalah online!

Bagaimana?

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

Perhatikan bahwa diulang rdi “qmlrrhp”dalam indeks ke-5, yang, jika direferensikan, akan menghasilkan prepending un, sehingga bisa sama-sama baik menjadi apa pun selain hatau p.

/// , 59 56 byte

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

Cobalah online!

Input berjalan setelah yang terakhir #.

Bagaimana itu bekerja:

Saya membuat optimasi yang mengurangi ukurannya menjadi 56 byte, tetapi karena itu menyulitkan saya akan menjelaskan versi aslinya, lalu menjelaskan 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

Intuisi: Tantangannya cukup sederhana, cukup tambahkan negatif tergantung pada awal kata. Namun, di ///, Anda tidak bisa adil concatenate if [...], Anda hanya bisa mengganti sesuatu mengikuti pola tertentu. Jadi dalam program ini, kata awal yang positif diganti dengan kata awal yang negatif. Itu #ditambahkan untuk memastikan bahwa sekali awal baru ditambahkan, tidak ada lagi awal baru yang akan ditambahkan. The #juga memungkinkan untuk melakukan 'segala sesuatu yang lain: un'.

Golf menggabungkan substitusi baru di ia mulai: /^/\/\/#/. Ini menggantikan semua ^dengan //#, yang merupakan pola umum di versi asli.

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

Membutuhkan semua huruf kapital.

Penjelasan:

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

Suntingan:

• Disimpan 7 byte berkat @ErtySeidohl ( charAt(0)-> [0])
• Disimpan 3 byte berkat @ edc65 (menetapkan awalan bersama untuk variabel)

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

Periksa karakter pertama dari kata itu terhadap daftar awalan khusus dan jika demikian mengubah awalan dari default un. Casing khusus qudimungkinkan dengan biaya 21 byte.

Haskell, 71 byte

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

Contoh penggunaan: f "legal"-> "illegal". Cobalah online!

Buat tabel pencarian pasangan awalan / pengganti untuk mencari karakter pertama dari string input dengan nilai default "un"jika tidak ditemukan.

Retina , 54 byte

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

Penjelasan:

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

Pertama kali saya menggunakan Retina. Itu bahasa yang cukup rapi.

Cobalah 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

Ya, ini masih lebih lama dari solusi yang ada. :)

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

Dalam hal ini perlu penjelasan apa pun, saya mengambil keuntungan dari pasangan q / h dan m / p dengan menggabungkan indeks mereka dalam string pencarian dengan mod 4, kemudian menggunakannya sebagai pencarian ke dalam array awalan.

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

Cobalah online!

Mathematica, 107 byte

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

Penjelasan:

StartOfString~~x:#:>#2<>x&adalah fungsi murni di mana argumen pertama adalah pola string yang cocok pada awal string dan argumen kedua adalah string untuk ditambahkan ke pertandingan. Ini mengembalikan aturan tertunda yang cocok untuk digunakan di dalam StringReplace. Ini kemudian diterapkan pada masing-masing pasangan yang {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}menghasilkan daftar aturan

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

Akhirnya daftar ini dimasukkan ke dalam StringReplaceyang memberikan operator pada string.

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 Online

Excel 78 byte

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

Saya menemukan beberapa pesaing dekat menggunakan metode berbeda yang mencetak 81 byte:

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

Dan 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

Menghemat beberapa byte dengan membalas di UPPERCASE, mis. Potent -> IMPOTENT.

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

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

Menggunakan:

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

Cobalah online .

Clojure, 65 byte

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

Yah ini membosankan ... tapi saya tidak bisa membuatnya lebih pendek. Setidaknya ada sedikit ruang putih.

OCaml, 85

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

Fungsi anonim, menggunakan pencocokan pola pada karakter pertama.