Tuyên bố miễn trừ trách nhiệm: Đây không phải là thách thức của tôi nhưng ThisGuy cho biết tôi vẫn ổn để đăng.

Thỉnh thoảng tôi muốn biến một từ thành đối diện, giống như happinessđi đến unhappiness. Thật không may khi điều này xảy ra, đôi khi não của tôi sẽ trống rỗng. Rồi một ngày, sau khi một điều khác xảy ra, tôi tự nghĩ "Đây là chương trình dành cho!"

Vì ngôn ngữ tiếng Anh có nhiều ngoại lệ, tôi đã tạo một danh sách chứa tiền tố cho chữ cái bắt đầu

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)

Bài tập

Đưa ra một đầu vào dưới dạng một chuỗi, làm cho chuỗi thành âm và xuất kết quả. Bạn có thể giả định rằng tất cả các đầu vào đưa ra sẽ phù hợp với các quy tắc trên. Đệ trình có thể là chương trình hoặc chức năng, không phải đoạn trích.

Đầu vào

Một chuỗi đơn, được lấy làm tham số hoặc từ STDIN

Đầu ra

Dạng phủ định của chuỗi đó, tuân thủ các quy tắc trên

Làm thế nào để chiến thắng

Đây là một môn đánh gôn nên mã ngắn nhất sẽ thắng

Python, 55 byte

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

Hãy thử trực tuyến!

Chúng ta cần xử lý 7 chữ cái bắt đầu khác nhau:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> irvà mọi thứ khác ->un

Chúng ta có thể lưu trữ tất cả các phủ định này trong một chuỗi và trích xuất một chuỗi thông qua cắt:

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

'ddiiiiuiimmlrnss'[i::7]

Bây giờ chúng ta cần tính toán chỉ số bắt đầu i. 'rlmphq'.findtrả về 0 cho 'r', 5 cho qvà -1 cho mọi thứ không có trong chuỗi. Để có được giá trị cần thiết từ 0 đến 6, chúng ta vẫn cần trừ giá trị trả về từ 5, dẫn đến mã này:

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

GNU sed , 50 byte

Bao gồm +1 cho -r

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

Không có gì lạ mắt. Sử dụng &trong thay thế để kết hợp một vài thay thế, vàt bỏ qua cái cuối cùng nếu một trong những sự thay thế đầu tiên xảy ra.

Hãy thử trực tuyến!

Thạch , 30 byte

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

Hãy thử trực tuyến!

Làm sao?

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

Lưu ý rằng lặp đi lặp lại rtrong “qmlrrhp”là trong chỉ mục thứ 5, trong đó, nếu tham chiếu, sẽ cho kết quả trong prepending un, vì vậy nó tốt như nhau có thể là bất cứ điều gì khác hơn hhay p.

/// , 59 56 byte

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

Hãy thử trực tuyến!

Đầu vào đi sau cùng cuối cùng #.

Làm thế nào nó hoạt động:

Tôi đã thực hiện tối ưu hóa giảm kích thước xuống 56 byte, nhưng vì điều đó làm phức tạp mọi thứ nên tôi sẽ giải thích phiên bản gốc, sau đó giải thích về 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

Trực giác: Thử thách đủ đơn giản, chỉ cần thêm tiêu cực tùy thuộc vào đầu từ. Tuy nhiên, trong ///, bạn không thể chỉ concatenate if [...], bạn chỉ có thể thay thế một cái gì đó theo một mẫu cụ thể. Vì vậy, trong chương trình này, bắt đầu từ tích cực được thay thế bằng bắt đầu từ phủ định. Đã #được thêm vào để đảm bảo rằng một khi bắt đầu mới được thêm vào, sẽ không có thêm sự khởi đầu mới nào được thêm vào. Điều này #cũng cho phép thực hiện 'mọi thứ khác: un'.

Golf kết hợp một sự thay thế mới khi anh ấy bắt đầu : /^/\/\/#/. Điều này thay thế tất cả ^với //#, đó là một mô hình phổ biến trong phiên bản gốc.

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

Yêu cầu tất cả chữ in hoa.

Giải trình:

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

Chỉnh sửa:

• Đã lưu 7 byte nhờ @ErtySeidohl ( charAt(0)->[0] )
• Đã lưu 3 byte nhờ @ edc65 (gán tiền tố được chia sẻ cho các biến)

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

Mẻ, 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%

Kiểm tra ký tự đầu tiên của từ so với danh sách các tiền tố tùy chỉnh và nếu có thì thay đổi tiền tố từ mặc định của un. Vỏ đặc biệt qucó thể có giá 21 byte.

Haskell, 71 byte

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

Ví dụ sử dụng: f "legal"-> "illegal".Hãy thử trực tuyến!

Xây dựng bảng tra cứu các cặp tiền tố / thay thế để tra cứu char đầu tiên của chuỗi đầu vào với giá trị mặc định "un"nếu không tìm thấy.

Võng mạc , 54 byte

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

Giải trình:

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

Lần đầu tiên tôi đã sử dụng Retina. Đó là một ngôn ngữ khá gọn gàng.

Hãy thử trực tuyến!

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

Vâng, nó vẫn còn dài hơn một giải pháp hiện có. :)

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

Trong trường hợp điều này cần bất kỳ lời giải thích nào, tôi đang tận dụng các cặp q / h và m / p bằng cách kết hợp chỉ mục của chúng trong chuỗi tìm kiếm với mod 4, sau đó sử dụng đó làm tra cứu vào mảng tiền tố.

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

Hãy thử trực tuyến!

Toán học, 107 byte

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

Giải trình:

StartOfString~~x:#:>#2<>x&là một hàm thuần túy trong đó đối số thứ nhất là một mẫu chuỗi để khớp ở đầu chuỗi và đối số thứ hai là một chuỗi để thêm vào khớp. Nó trả về một quy tắc trì hoãn phù hợp để sử dụng trong StringReplace. Điều này sau đó được áp dụng cho từng cặp {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}dẫn đến danh sách các quy tắc

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

Cuối cùng, danh sách này được truyền vào StringReplaceđể cung cấp một toán tử trên chuỗi.

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;

Phiên bản trực tuyến

Excel 78 byte

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

Tôi tìm thấy một số ứng cử viên gần gũi bằng cách sử dụng các phương pháp khác nhau ghi được 81 byte:

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

Và 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

Lưu một vài byte bằng cách trả lời trong UPPERCASE, ví dụ như mạnh -> TÁC ĐỘNG.

Perl, 49 + 1 ( -pcờ) = 50 byte

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

Sử dụng:

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

Hãy thử trực tuyến .

Clojure, 65 byte

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

Chà, điều này thật nhàm chán ... nhưng tôi không thể làm cho nó ngắn hơn được nữa. Ít nhất là có rất ít khoảng trắng.

Tháng 10, 85

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

Hàm ẩn danh, sử dụng khớp mẫu trên char đầu tiên của nó.