Отказ от ответственности: это не моя задача, но ThisGuy сказал, что я в порядке, чтобы опубликовать.

Иногда я хочу сделать слово в противоположность, как будто happinessидет unhappiness. К сожалению, когда это происходит, мой мозг иногда становится пустым. И вот однажды, после еще одного такого случая, я подумал про себя: «Для этого и программы!»

Поскольку в английском языке есть много исключений, я создал список, который содержит префикс для начальной буквы

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)

задача

Задавая входные данные в виде строки, сделайте строку отрицательной и выведите результат. Вы можете предположить, что все приведенные данные будут соответствовать приведенным выше правилам. Материалы могут быть программами или функциями, а не фрагментами.

вход

Одна строка, взятая либо в качестве параметра, либо из STDIN

Выход

Отрицательная форма этой строки, соответствующая приведенным выше правилам

Как победить

Это код-гольф, поэтому выигрывает самый короткий код

Python, 55 байт

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

Попробуйте онлайн!

Нам нужно обработать 7 разных начальных букв:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> irи все остальное ->un

Мы можем хранить все эти отрицания в одной строке и извлекать правильную через разрезание:

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

'ddiiiiuiimmlrnss'[i::7]

Теперь нам нужно рассчитать начальный индекс i. 'rlmphq'.findвозвращает 0 для 'r', 5 для qи -1 для всего, что не содержится в строке. Чтобы получить необходимое значение от 0 до 6, нам все равно нужно вычесть возвращаемое значение из 5, что приведет к следующему коду:

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

GNU sed , 50 байтов

Включает +1 для -r

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

Ничего фантастического. Используется &в замене, чтобы объединить несколько замен и tпропустить последнюю, если произойдет одна из первых замен.

Попробуйте онлайн!

Желе , 30 байт

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

Попробуйте онлайн!

Как?

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

Обратите внимание , что повторяется rв “qmlrrhp”в 5 - индекс, который, если ссылки, приведет к предваряя un, поэтому он может одинаково хорошо быть ничем иным, hили p.

/// , 59 56 байт

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

Попробуйте онлайн!

Ввод идет после самого последнего #.

Как это устроено:

Я сделал оптимизацию, которая уменьшила размер до 56 байт, но так как это усложняет вещи, я объясню оригинальную версию, а затем объясню гольф.

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

Интуиция: Задача достаточно проста, просто добавьте минус в зависимости от начала слова. Однако в /// вы не можете просто concatenate if [...], вы можете только заменить что-то по определенной схеме. Таким образом, в этой программе положительные начала слова заменяются отрицательными начала слова. #Было добавлено , чтобы убедиться , что когда - то было добавлено новое начало, не будет добавлено не более новые начинания. Это #также позволило сделать «все остальное: un».

Гольф включает в себя новую замену в он начинающийся: /^/\/\/#/. Это заменяет все ^на //#, что было распространено в оригинальной версии.

TI-Basic, 104 байта

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

Требуются все заглавные буквы.

Объяснение:

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 байт)

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

Редактирование:

• Сохранено 7 байт благодаря @ErtySeidohl ( charAt(0)-> [0])
• Сохранено 3 байта благодаря @ edc65 (назначение общих префиксов переменным)

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

Пакет, 114 байт

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

Проверяет первый символ слова в списке пользовательских префиксов и, если это так, меняет префикс по умолчанию на un. Специальный корпус quвозможен при стоимости 21 байт.

Haskell, 71 байт

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

Пример использования: f "legal"-> "illegal". Попробуйте онлайн!

Создайте таблицу поиска пар префикс / замена для поиска первого символа входной строки со значением по умолчанию, "un"если оно не найдено.

Сетчатка , 54 байта

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

Объяснение:

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

Впервые я использовал Retina. Это довольно аккуратный язык.

Попробуйте онлайн!

Javascript, 72 71 66 61 60 59 байт

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

Да, это все еще дольше, чем существующее решение. :)

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

В случае, если это требует какого-либо объяснения, я использую пары q / h и m / p, комбинируя их индекс в строке поиска с модом 4, а затем использую его как поиск в массиве префиксов.

C 109 107 байт

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

Попробуйте онлайн!

Mathematica, 107 байт

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

Объяснение:

StartOfString~~x:#:>#2<>x&является чистой функцией, где первый аргумент является строковым шаблоном для сопоставления в начале строки, а второй аргумент является строкой, предшествующей сопоставлению. Возвращает отложенное правило, пригодное для использования в StringReplace. Затем это применяется к каждой из пар, что {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}приводит к списку правил

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

Наконец этот список передается в StringReplaceкоторый дает оператор на строки.

PHP, 101 байт

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

Онлайн версия

Excel 78 байт

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

Я нашел несколько близких соперников, используя разные методы, которые набрали 81 байт:

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

И 84 байта:

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

REXX, 78 байт

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

Сохраняет несколько байтов, отвечая в верхнем регистре, например, potent -> IMPOTENT.

Perl, 49 + 1 ( -pфлаг) = 50 байтов

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

С помощью:

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

Попробуйте онлайн .

Clojure, 65 байт

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

Ну, это скучно ... но я не мог сделать это короче. По крайней мере, очень мало пробелов.

OCaml, 85

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

Анонимная функция, использует сопоставление с образцом на своем первом символе.