स्ट्रिंग को नेगेट करें

12

अस्वीकरण: यह मेरी चुनौती नहीं है लेकिन 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 से लिया जाता है

उत्पादन

उपरोक्त नियमों के अनुरूप, उस स्ट्रिंग का नकारात्मक रूप

कैसे जीतें

यह एक कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है

code-golf  string 
— जादू ऑक्टोपस Urn
स्रोत
4
क्या हम मान सकते हैं कि हमें कभी भी ऐसा शब्द नहीं मिलेगा जो qबिना एक के साथ शुरू होता है u।
— बिजनेस कैट
3
मेरे सिर के ऊपर से, qadi, qat, ऊपर उल्लिखित qi, qirsh, और qwerty। (मैं बहुत स्क्रैबल
— खेलता हूं
4
@wsbltc खैर, कुछ उचित है , लेकिन वे बहुत अधिक अन्य भाषाओं से सभी शब्द उधार लिया है ताकि वे वास्तव में अंग्रेजी के रूप में गिना जाए। तो क्या हम मान सकते हैं कि qहमेशा uस्ट्रिंग में अनुगमन होता है या नहीं?
— बिज़नेस कैट
3
हाँ आप मान सकते हैं कि यह हमेशा एकu
11
इस चुनौती से एक शिशु काफी दुखी हो सकता है ...
— 10

जवाबों:

10

पायथन, 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'.find0 के लिए 0 'r', 5 के लिए qऔर -1 रिटर्न । 0 से 6 तक आवश्यक मूल्य प्राप्त करने के लिए हमें अभी भी 5 से वापसी मूल्य को घटाना होगा, जिसके परिणामस्वरूप यह कोड है:

'ddiiiiuiimmlrnss'[5-'rlmphq'.find(n[0])::7]
— OVS
स्रोत
यह वास्तव में प्यारा है!
— स्टीव बेनेट
क्या कोई समझा सकता है कि यह कैसे काम करता है? मैं समझता हूं कि स्लाइस नोटेशन के साथ क्या हो रहा है, लेकिन मैजिक स्ट्रिंग्स ddiiiiuiimmlrnssऔर rlmphqसंख्या क्या हैं 5, स्लाइस स्किप 7 क्यों है?
— 19
@ कीटिंग ने एक स्पष्टीकरण जोड़ा। मुझे आशा है कि यह आपकी मदद करेगा
— 20
6

GNU sed , 50 बाइट्स

के लिए +1 शामिल है -r

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

कुछ भी आकर्षक नहीं। &कुछ प्रतिस्थापनों को संयोजित करने के लिए प्रतिस्थापन में उपयोग करता है, और tयदि अंतिम प्रतिस्थापन में से एक होता है, तो अंतिम को छोड़ देना है।

इसे ऑनलाइन आज़माएं!

— रिले
स्रोत
5

जेली , 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

ध्यान दें कि 5 वें सूचकांक में दोहराया rगया “qmlrrhp”है, जिसे संदर्भित किया जाता है un, तो इसका परिणाम होगा , इसलिए यह समान रूप से hया इसके अलावा कुछ भी हो सकता है p।

— जोनाथन एलन
स्रोत
4

/// , 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 [...]कर सकते, आप केवल एक विशिष्ट पैटर्न के बाद कुछ बदल सकते हैं। इसलिए इस कार्यक्रम में, सकारात्मक शब्द की शुरुआत को नकारात्मक शब्द की शुरुआत के साथ बदल दिया जाता है। यह #सुनिश्चित करने के लिए जोड़ा गया था कि एक बार एक नई शुरुआत हो जाने के बाद, कोई और नई शुरुआत नहीं जोड़ी जाएगी। यह #भी 'सब कुछ: संयुक्त राष्ट्र' करने के लिए संभव बना दिया।

गोल्फ शुरुआत में एक नया प्रतिस्थापन शामिल करता है /^/\/\/#/:। यह सभी ^को बदल देता है //#, जो मूल संस्करण में एक सामान्य पैटर्न था।

— कॉमरेड स्पार्कलपनी
स्रोत
3

टीआई-बेसिक, 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
— pizzapants184
स्रोत
3

जावास्क्रिप्ट ( 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]) के लिए धन्यवाद
  • @ Edc65 के लिए 3 बाइट्स को सहेजा गया (चरों पर साझा उपसर्ग असाइन करना)

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">
स्निपेट का विस्तार करें

— forrert
स्रोत
1
यदि आप IE7 के साथ पिछड़े संगतता के बारे में परवाह नहीं करते हैं, तो क्या आप w[0]इसके बजाय उपयोग नहीं कर सकते w.charAt(0)?
— एरिटी सीडोहेल
@ErtySeidohl धन्यवाद! बस कुछ नया सीखा ;-)
— forrert
मैं यहां नया हूं, लेकिन क्या सिर्फ एक जवाब देना शुरू करना वैध है w=>...? वास्तविक फ़ंक्शन परिभाषा में शामिल होंगे let f=w=>...? (शायद कहीं पूछे जाने वाले प्रश्न में कवर किया गया ...)
— स्टीव बेनेट
@SteveBennett हाँ यह वैध है। फ़ंक्शन का नामकरण प्रासंगिक नहीं है
— edc65
1
w=>({q:a='dis',h:a,l:'il',m:b='im',p:b,r:'ir'}[w[0]]||'un')+w3 बाइट्स कम
— edc65
2

बैच, 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। qu21 बाइट्स की लागत पर विशेष आवरण संभव है।

— नील
स्रोत
2

हास्केल, 71 बाइट्स

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

प्रयोग उदाहरण: f "legal"-> "illegal"। इसे ऑनलाइन आज़माएं!

"un"यदि नहीं पाया जाता है , तो एक डिफ़ॉल्ट मान के साथ इनपुट स्ट्रिंग के पहले चार को देखने के लिए उपसर्ग / प्रतिस्थापन जोड़े की एक खोज तालिका बनाएँ ।

— nimi
स्रोत
2

रेटिना , 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$+

पहली बार मैंने रेटिना का उपयोग किया है। यह बहुत साफ-सुथरी भाषा है।

इसे ऑनलाइन आज़माएं!

— Okx
स्रोत
बहुत अच्छी पहली भाषा में कोशिश करो! +1
— अर्जुन
और इसके साथ ही आपके पास 2500 प्रतिनिधि हैं! बधाई हो!
— अर्जुन
और आपका यूजर इंडेक्स 26600 है!
— अर्जुन
इतना परफेक्ट बेस -10!
— अर्जुन
2

जावास्क्रिप्ट, 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 के साथ जोड़कर ले रहा हूं, फिर उपसर्ग सरणी में देखने के रूप में इसका उपयोग कर रहा हूं।

— स्टीव बेनेट
स्रोत
बहुत बढ़िया जवाब। के searchबजाय का उपयोग करके 1 बाइट बचाएं indexOf। और कुछ और, मुझे लगता है कि &%
— edc65
धन्यवाद! मैं नहीं जानता था search। यह नहीं देखा जा सकता है कि कैसे & ट्रिक का काम किया जाए - यह सही होगा यदि मेरी सरणी केवल 4 तत्व है।
— स्टीव बेनेट
1

गणितज्ञ, १०hem बाइट्स

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जिसमें स्ट्रिंग्स पर एक ऑपरेटर दिया जाता है।

— ngenisis
स्रोत
2
क्या मैथेमेटिका में हर चीज के लिए एक बेसिन है?
1

एक्सेल 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
— इंजीनियर टोस्ट
स्रोत
0

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

UPPERCASE में उत्तर देकर कुछ बाइट्स बचाता है, जैसे शक्तिशाली -> महत्वपूर्ण।

— idrougge
स्रोत
0

क्लोजर, 65 बाइट्स

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

खैर यह उबाऊ है ... लेकिन मैं इसे कोई छोटा नहीं बना सकता। कम से कम व्हॉट्सएप बहुत कम है।

— NikoNyrh
स्रोत
0

OCaml, 85

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

बेनामी फ़ंक्शन, अपने पहले चार्ट पर पैटर्न मिलान का उपयोग करता है।

— रेडौने लाल
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.