Avertissement: Ce n'est pas mon défi, mais ThisGuy a dit que j'étais d'accord pour poster.

Parfois, je veux faire un mot en son contraire, comme happinessva à unhappiness. Malheureusement, lorsque cela se produit, mon cerveau se vide parfois. Puis un jour, après un autre événement, je me suis dit "C'est à ça que servent les programmes!"

Comme la langue anglaise a de nombreuses exceptions, j'ai créé une liste qui contient le préfixe de la lettre de départ

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)

Tâche

Étant donné une entrée sous forme de chaîne, transformez la chaîne en son négatif et affichez le résultat. Vous pouvez supposer que toutes les entrées fournies répondront aux règles ci-dessus. Les soumissions peuvent être des programmes ou des fonctions, pas des extraits.

Contribution

Une seule chaîne, prise soit comme paramètre, soit depuis STDIN

Production

La forme niée de cette chaîne, conforme aux règles ci-dessus

Comment gagner

Ceci est un code-golf donc le code le plus court gagne

Python, 55 octets

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

Essayez-le en ligne!

Nous devons gérer 7 lettres de départ différentes:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> iret tout le reste ->un

Nous pouvons stocker toutes ces négations dans une seule chaîne et extraire la bonne par découpage:

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

'ddiiiiuiimmlrnss'[i::7]

Maintenant, nous devons calculer l'indice de départ i. 'rlmphq'.findrenvoie 0 pour 'r', 5 pour qet -1 pour tout ce qui n'est pas contenu dans la chaîne. Pour obtenir la valeur nécessaire de 0 à 6, nous devons encore soustraire la valeur de retour de 5, ce qui donne ce code:

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

GNU sed , 50 octets

Comprend +1 pour -r

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

Rien d'extraordinaire. Utilise &dans le remplacement pour combiner quelques substitutions et tpour sauter la dernière si l'une des premières substitutions se produit.

Essayez-le en ligne!

Gelée , 30 octets

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

Essayez-le en ligne!

Comment?

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

Notez que le répété rdans se “qmlrrhp”trouve dans le 5ème indice, ce qui, s'il était référencé, entraînerait un préfixe un, donc il pourrait tout aussi bien être autre chose que hou p.

/// , 59 56 octets

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

Essayez-le en ligne!

L'entrée va après la toute dernière #.

Comment ça fonctionne:

J'ai fait une optimisation qui a réduit la taille à 56 octets, mais comme cela complique les choses, je vais expliquer la version originale, puis expliquer le 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: Le défi est assez simple, il suffit d'ajouter le négatif selon le début du mot. Cependant, dans ///, vous ne pouvez pas simplement concatenate if [...], vous pouvez uniquement remplacer quelque chose suivant un modèle spécifique. Ainsi, dans ce programme, les débuts de mots positifs sont remplacés par les débuts de mots négatifs. Le a #été ajouté pour s'assurer qu'une fois qu'un nouveau commencement a été ajouté, plus aucun nouveau commencement ne serait ajouté. Le a #également permis de faire «tout le reste: un».

Le golf intègre une nouvelle substitution à il commençait: /^/\/\/#/. Cela remplace tout ^par //#, ce qui était un modèle courant dans la version originale.

TI-Basic, 104 octets

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

Nécessite toutes les majuscules.

Explication:

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 octets)

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

Modifications:

• 7 octets enregistrés grâce à @ErtySeidohl ( charAt(0)-> [0])
• Sauvegardé 3 octets grâce à @ edc65 (attribution de préfixes partagés aux variables)

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

Lot, 114 octets

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

Vérifie le premier caractère du mot par rapport à la liste des préfixes personnalisés et, si tel est le cas, change le préfixe par défaut un. Un boîtier spécial quest possible au coût de 21 octets.

Haskell, 71 octets

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

Exemple d'utilisation: f "legal"-> "illegal". Essayez-le en ligne!

Construisez une table de recherche de paires préfixe / remplacement pour rechercher le premier caractère de la chaîne d'entrée avec une valeur par défaut "un"sinon.

Rétine , 54 octets

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

Explication:

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

C'est la première fois que j'utilise Retina. C'est une langue assez soignée.

Essayez-le en ligne!

Javascript, 72 71 66 61 60 59 octets

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

Oui, c'est encore plus long qu'une solution existante. :)

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

Dans le cas où cela nécessite une explication, je profite des paires q / h et m / p en combinant leur index dans la chaîne de recherche avec un mod 4, puis en l'utilisant comme recherche dans le tableau de préfixes.

C, 109 107 octets

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

Essayez-le en ligne!

Mathematica, 107 octets

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

Explication:

StartOfString~~x:#:>#2<>x&est une fonction pure où le premier argument est un modèle de chaîne à faire correspondre au début de la chaîne et le deuxième argument est une chaîne à ajouter à la correspondance. Il renvoie une règle retardée pouvant être utilisée à l'intérieur StringReplace. Ceci est ensuite appliqué à chacune des paires {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}résultant en la liste des règles

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

Enfin cette liste est passée dans StringReplacelaquelle donne un opérateur sur les chaînes.

PHP, 101 octets

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

Version en ligne

Excel 78 octets

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

J'ai trouvé des candidats proches utilisant différentes méthodes qui ont marqué 81 octets:

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

Et 84 octets:

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

REXX, 78 octets

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

Enregistre quelques octets en répondant en MAJUSCULE, par exemple puissant -> IMPOTENT.

Perl, 49 + 1 ( -pindicateur) = 50 octets

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

En utilisant:

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

Essayez-le en ligne .

Clojure, 65 octets

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

Eh bien, c'est ennuyeux ... mais je ne pouvais pas le raccourcir. Au moins, il y a très peu d'espaces.

OCaml, 85

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

Fonction anonyme, utilise la correspondance de motifs sur son premier caractère.