Feragatname: Bu benim zorluğum değil ama ThisGuy , yayınlamakta uygun olduğumu söyledi.

Gibi Bazen ben, 's ters bir kelime yapmak istiyorum happinessgider unhappiness. Ne yazık ki bu olduğunda, beynim bazen boşalacak. Sonra bir gün, bir daha bu olaydan sonra, kendi kendime "Programlar bunun için!" Diye düşündüm.

İngilizce dilinin birçok istisnası olduğundan, başlangıç ​​harfinin önekini içeren bir liste oluşturdum

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)

Görev

Dize olarak bir girdi verildiğinde, dizeyi negatif haline getirin ve sonucu alın. Verilen tüm girdilerin yukarıdaki kurallara uyacağını varsayabilirsiniz. Gönderiler parçacıklar değil, programlar veya işlevler olabilir.

Giriş

Parametre olarak veya STDIN'den alınan tek bir dize

Çıktı

Yukarıdaki kurallara uygun olarak, dizenin reddedilen şekli

Nasıl kazanılır

Bu bir kod golfü yani kısa kod kazanıyor

Python, 55 bayt

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

Çevrimiçi deneyin!

7 farklı başlangıç ​​harfi kullanmamız gerekiyor:
g-> dis, h-> dis, p-> im, m-> im, l-> il, r-> irve diğer her şey ->un

Tüm bu olumsuzlukları tek bir dizede saklayabilir ve doğru olanı dilimleme yoluyla çıkarabiliriz:

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

'ddiiiiuiimmlrnss'[i::7]

Şimdi başlangıç ​​indeksini hesaplamamız gerekiyor i. dizede bulunmayan her şey için 'rlmphq'.find0 için 'r', 5 için qve -1 için döner . Gerekli değeri 0'dan 6'ya almak için yine de dönüş değerini 5'ten çıkarmamız gerekir, bu da bu kodla sonuçlanır:

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

GNU sed , 50 bayt

İçin +1 içerir -r

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

Hiçbir şey fantezi. Yedekte &, birkaç oyuncu değişikliğini birleştirmek tve ilk oyuncu değişikliklerinden biri gerçekleşirse sonuncuyu atlamak için kullanılır.

Çevrimiçi deneyin!

Jöle , 30 bayt

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

Çevrimiçi deneyin!

Nasıl?

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

Tekrarlanan bu Not riçinde “qmlrrhp”, başvurulan eğer prepending yol açacağı 5 endeksi, olduğu unyani eşit derecede iyi başka bir şey olabilir, hya da p.

/// , 59 56 bayt

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

Çevrimiçi deneyin!

Girdi en sondan sonra gider #.

Nasıl çalışır:

Boyutu 56 bayta düşüren bir optimizasyon yaptım, ancak bu şeyleri karmaşıklaştırdığı için orijinal sürümü açıklayacağım, sonra golfü açıklayacağım.

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

Sezgi: Zorluk yeterince basittir, sadece kelimenin başına bağlı olarak negatifleri ekleyin. Ancak, /// 'de, sadece concatenate if [...]belirli bir kalıbı izleyen bir şeyi değiştiremezsiniz. Yani bu programda, pozitif kelime başlangıçları negatif kelime başlangıçları ile değiştirilir. #Emin yeni bir başlangıç eklendi kez, artık yeni başlangıçlar ilave edileceğini yapmak eklendi. #Ayrıca ': un diğer her şeyi' yapmak mümkün kıldı.

Golf başlayan kendisinden yeni bir ikame içerir: /^/\/\/#/. Bu, tüm değiştirir ^ile //#orijinal versiyonunda ortak modeli olan,.

TI-Basic, 104 bayt

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

Tüm büyük harfleri gerektirir.

Açıklama:

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

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

Düzenlemeler:

• @ErtySeidohl ( charAt(0)-> [0]) sayesinde 7 bayt kaydedildi
• @ Edc65 (değişkenlere paylaşılan önek atama) sayesinde 3 bayt kaydedildi

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

Toplu, 114 bayt

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

Sözcüğün ilk karakterini özel önekler listesine göre denetler ve eğer öyleyse öneki varsayılandan değiştirir un. Özel kasa qu21 bayt maliyetle mümkündür.

Haskell, 71 bayt

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

Kullanım örneği: f "legal"-> "illegal". Çevrimiçi deneyin!

Bulunmazsa, varsayılan değer olan giriş dizesinin ilk karakterini aramak için önek / değiştirme çiftleri için bir arama tablosu oluşturun "un".

Retina , 54 bayt

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

Açıklama:

             {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'yı ilk kez kullandım. Oldukça temiz bir dil.

Çevrimiçi deneyin!

JavaScript, 72 71 66 61 60 59 bayt

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

Evet, hala mevcut bir çözümden daha uzun. :)

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

Bunun herhangi bir açıklamaya ihtiyacı olması durumunda, q / h ve m / p çiftlerinden, arama dizesindeki dizinlerini bir mod 4 ile birleştirerek ve ardından önek dizisine arama olarak kullanarak faydalanıyorum.

C, 109107 bayt

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

Çevrimiçi deneyin!

Mathematica, 107 bayt

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

Açıklama:

StartOfString~~x:#:>#2<>x&birinci bağımsız değişken, dizenin başında eşlenecek bir dize deseni ve ikinci bağımsız değişken ise eşleşmenin önüne bir dize olduğu saf bir işlevdir . İçinde kullanıma uygun gecikmeli bir kural döndürür StringReplace. Bu, daha sonra {{"q"|"h","dis"},{"l","il"},{"m"|"p","im"},{"r","ir"},{_,"un"}}kurallar listesi ile sonuçlanan her bir çifte uygulanır.

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

Sonunda StringReplacedizeye bir operatör veren bu liste aktarılır .

PHP, 101 Bayt

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

Çevrimiçi sürüm

Excel 78 bayt

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

81 bayt alan farklı yöntemler kullanarak bazı yakın yarışmacılar buldum:

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

Ve 84 bayt:

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

REXX, 78 bayt

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

UPPERCASE'e yanıt vererek birkaç bayt kaydeder, örn. Güçlü -> IMPOTENT.

Perl, 49 + 1 ( -pbayrak) = 50 bayt

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

Kullanımı:

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

Çevrimiçi deneyin .

Clojure, 65 bayt

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

Bu sıkıcı ... ama daha kısa yapamadım. En azından çok az boşluk var.

OCaml, 85

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

Anonim işlev, ilk karakterinde desen eşleşmesini kullanır.