यूनिवर्सल स्पूकी मेमे अनुवादक


43

परिचय

पता चलता है, एलियंस जितना हम करते हैं, उतना ही प्यार करता है। हमारे द्वारा अब तक की गई प्रत्येक विदेशी दौड़ का अपना संस्करण है 2spooky4me( निम्न प्रश्न देखें ) और समकक्ष, हालांकि, कुछ भिन्नता के साथ। ग्रह CUTE1f के निवासियों को बहुत सारे स्पूक संभाल नहीं सकते हैं, इसलिए उनका पसंदीदा स्पूक है 1spooky2me, जबकि कंकाल 7 मेकर्स उन्हें कुछ स्पूक से प्यार करते हैं, इसलिए वे उपयोग करते हैं 9spooky11me

चुनौती

मेमे का अनुवाद करना कठिन काम है, इसलिए आपको इन लोगों को मेमेनेट तक सही तरीके से पहुंचने में मदद करने के लिए एक सार्वभौमिक मेम ट्रांसलेटर लिखने का काम सौंपा गया है। आपका कार्यक्रम एक मेम और एक परिवर्तन को उस मेम में अंकों के अनुक्रमों पर लागू करने के लिए स्वीकार करेगा, जो किसी अलग ग्रह के निवासियों के लिए उपयुक्त हो।

इनपुट

आपके प्रोग्राम को दो स्ट्रिंग इनपुट प्राप्त होंगे:

  1. इनपुट मेमे (उदा 2spooky4me)। मेल खाता है [a-zA-Z0-9]+
  2. इसे लागू करने के लिए परिवर्तन (जैसे +1, से जाने के 2spooky4meलिए 3spooky5me)। मेल खाता है [+\-*/^]\d+(आप को स्वीकार करना चाहिए +, -, *, /, और ^ऑपरेटर के रूप में, अपनी भाषा में देशी प्रतिनिधित्व की परवाह किए बिना)।

उत्पादन

आपके प्रोग्राम को इनपुट मेमे में अंकों के अनुक्रम में लागू किए गए परिवर्तन के साथ एक स्ट्रिंग आउटपुट (मानक आउटपुट या समकक्ष के लिए मुद्रित) को वापस करना होगा। घटनाओं के एक अजीब मोड़ में, यह भी पता चला है कि अब तक सामना किए गए सभी दौड़ आंशिक लोगों पर अभिन्न मेमों को पसंद करते हैं, इसलिए इन परिवर्तनों को पूर्णांक अंकगणित (जैसे 1spooky1me /2परिणाम में होना चाहिए 0spooky0me) करना चाहिए ।

उदाहरण

मानक अंकगणितीय संचालन लागू होते हैं:

Input:  2spooky4me +1
Output: 3spooky5me

Input:  2spooky4me -1
Output: 1spooky3me

Input:  2spooky4me *15
Output: 30spooky60me

Input:  10spooky900me /5
Output: 2spooky180me

अंक अनुक्रम अभिन्न हैं; पूर्णांक विच्छेदन इस तरह के मामलों में होना चाहिए:

Input:  idontunderstandmemes3 /2
Output: idontunderstandmemes1

आपके इनपुट में कोई अंक अनुक्रम नहीं हो सकता है:

Input:  notreallyafunnymeme *100
Output: notreallyafunnymeme

भले ही यह आपकी पसंद की भाषा में एक देशी ऑपरेशन न हो, आपको एक्सप्रेशन का समर्थन करना चाहिए:

Input:  2spooky4me ^3
Output: 8spooky64me

स्ट्रिंग में अंक अनुक्रमों की संख्या की स्ट्रिंग लंबाई पर कोई सीमा नहीं है:

Input:  some1meme2sequences3can4be5really6long7 /2
Output: some0meme1sequences1can2be2really3long3

परिशिष्ट

यदि आपकी भाषा एक भाषा सुविधा के रूप में मनमाने ढंग से सटीक पूर्णांक का समर्थन करती है, तो आपको उन का उपयोग करना चाहिए। यदि ऐसा नहीं होता है, तो आपको मनमानी-सटीक पूर्णांक का समर्थन करने की आवश्यकता नहीं है। उदाहरण के लिए, आपको Integerइसकी जगह हास्केल का उपयोग करना चाहिए Intक्योंकि यह भाषा के हिस्से के रूप में उपलब्ध है; में Java, आपको उपयोग करने की आवश्यकता नहीं है BigIntegerक्योंकि यह एक पुस्तकालय सुविधा है, न कि एक भाषा सुविधा।

Input:  2000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky4me /2
Output: 1000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky2me

यह , इसलिए मानक कमियां निषिद्ध हैं, और बाइट्स जीत में सबसे छोटा जवाब है!

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से लीडरबोर्ड उत्पन्न करता है) ए प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


3
आपका अंतिम परीक्षण मामला गलत है। आपके पास आउटपुट में इसके लिए बहुत सारे शून्य हैं / 5 होने के लिए।
निक हार्टले

5
सबसे पहले यह एक उचित रूप से अच्छी तरह से एक साथ पहली पोस्ट है, इसलिए बधाई :) नोट हमारे पास एक सैंडबॉक्स है जहां आप अपनी चुनौती को लाइव करने से पहले अपनी प्रतिक्रिया पोस्ट कर सकते हैं।
FryAmTheEggman

3
PPCG में आपका स्वागत है (भले ही आप जाहिरा तौर पर 2+ साल से यहां हैं)। अच्छी पहली चुनौती। क्या मनमाने ढंग से सटीक पूर्णांक के बारे में परिशिष्ट जनादेश देता है, उदाहरण के लिए, जावा कोBigInteger अपनी गणना के लिए उपयोग करना चाहिए ?
AdmBorkBork

18
हर विदेशी जाति जो हमने अब तक का सामना किया है ... यह पूरी तरह से सच है! :-)
लुइस मेंडो

2
यह आपकी चुनौती है और अंततः आपके ऊपर है, लेकिन यह वास्तव में उन भाषाओं के प्रति उचित नहीं है जो एक अलग वाक्यविन्यास का उपयोग करने के लिए होती हैं।
डेनिस

जवाबों:


10

जोल्फ, 15 14 बाइट्स

ρi«\d+»dC!6+HI

यहाँ यह कोशिश करो!

व्याख्या

ρi«\d+»dC!6+HI
ρ «\d+»         replace all digits
 i              in the input
       d        (functional replace)
         !6     eval (using jolf's custom infix eval)
           +H   the number as a string plus
             I  the second input
        C       floor the result (integer truncate)

ध्यान दें, मैंने इस चुनौती के बाद जोल्फ को अपडेट किया, जिसमें कुछ RegExp बिल्डइन शामिल हैं। यह 12 11 बाइट्स हो सकता है :

ρiLRdC!6+HI

24

रूबी, 50 44 43 बाइट्स

FGITW जवाब। जल्दी जाना है!

6 बाइट बचाने के लिए @ निएल को धन्यवाद।

ओह ठीक है, 44 पार कर गया अभी भी 44 है

->m,t{m.gsub(/\d+/){eval$&+t.sub(?^,'**')}}

ओह, यार, यह लगभग बिल्कुल एक उत्तर है जो मैं दूर पर पोक कर रहा था a=gets;$><<gets.gsub(/\d+/){eval$&+a}:। मेरा याद आया ^! = ** बात, हालांकि, और शायद थोड़ा लंबा है।
निक हार्टले

3
+1 करने के लिए आपके पूरे समाधान को पावरबेल में केवल संभालने के लिए 4 बाइट्स से कम होना चाहिए ^। : D
AdmBorkBork

15

पर्ल, 36 34 बाइट्स

s/\d+/"0|$&$^I"=~s#\^#**#r/gee

स्रोत कोड 30 बाइट्स लंबा है और इसके लिए स्विच -pi( +4 बाइट्स ) की आवश्यकता होती है । यह पहला इनपुट STDIN से लेता है, दूसरा इनपुट तर्क के रूप में -i

2 बाइट बंद करने के लिए @DenisIbaev को धन्यवाद!

Ideone पर इसका परीक्षण करें ।


हां, मुझे लगा कि अगर कोई मेरे रूबी के जवाब को हरा सकता है, तो यह डेनिस और / या पर्ल में होगा, और आपने एक ही समय में दोनों उम्मीदों को पूरा किया
वैल्यू इंक

1
-pi4 बाइट्स है?
कैलक्यूलेटरफैलीन

@CatsAreFluffy वर्तमान सहमति झंडे के बिना आह्वान से संपादित दूरी की गणना करने के लिए है। जिसमें -piबाकी कमांड से अलग होने के लिए स्पेस शामिल है ।
डेनिस

"0|$&"से छोटा है "0|".$&
डेनिस इबाव

@DenisIbaev चूंकि इनपुट अल्फ़ान्यूमेरिक है, इसलिए "0|$&$^I"भी काम करता है। धन्यवाद!
डेनिस

9

PowerShell v2 +, 139 137 बाइट्स

param($a,$b)-join($a-split"(\d+)"|%{if($_-match"\d+"){if($b[0]-ne'^'){[math]::Floor((iex $_$b))}else{"$_*"*$b.Trim('^')+1|iex}}else{$_}})

Ooof ... 47 बाइट्स सिर्फ ^इसलिए खाते हैं क्योंकि वह PowerShell में एक मूल ऑपरेटर नहीं है। 2 बाइट्स @TessellatingHeckler की बदौलत सहेजे गए।

के रूप में इनपुट लेता है $a=<word>, $b=<operation>जैसे, .\universal-spooky-meme.ps1 2spooky4me ^3। हम -split $aअंकों पर, यह कहते हुए कि Parens में हम delimiters रखते हैं, और परिणामी सरणी को एक लूप के माध्यम से पाइप करते हैं |%{...}। यदि वर्तमान टुकड़ा एक संख्या है, तो हम पहले में हैं if। हमें यह जांचने की आवश्यकता है कि क्या पहला चरित्र $bहै ^। यदि यह नहीं है, तो हम बस अपने वर्तमान टुकड़े को समेटते हैं $bऔर इसे iex(इसी तरह eval) भेजते हैं , फिर पाइप लाइन पर छोड़ देते हैं। अन्यथा, हमें "$_*"*$b.Trim('^')+1पाइप iexलाइन के साथ एक घातांक स्ट्रिंग बनाने और पाइप लाइन पर छोड़ने की आवश्यकता है। दिए गए 2spooky4me ^3उदाहरण के लिए, यह क्रमशः होगा 2*2*2*1और 4*4*4*1

अन्यथा, हम बस स्ट्रिंग को छोड़ देते हैं-जैसा कि पाइपलाइन पर है।

उन सभी परिणामों -joinको एक स्ट्रिंग में एक साथ एड किए जाने से पहले इनकैप्सुलेटिंग परेंस के साथ पाइप लाइन से इकट्ठा किया जाता है । यह पाइपलाइन पर फिर से छोड़ दिया गया है, और आउटपुट कार्यक्रम समाप्ति पर निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\universal-spooky-meme.ps1 2spooky4me ^5
32spooky1024me

PS C:\Tools\Scripts\golfing> .\universal-spooky-meme.ps1 2spooky4me /3
0spooky1me

मैंने जवाब देखने से पहले अपना लिखा, फिर मैंने आपके कुछ विचारों पर चुटकी ली - धन्यवाद। मुझे लगता है कि आप बदल सकते Floor(("$_$b"|iex))के साथ Floor((iex $_$b))एक जोड़े को बचाने के लिए, या हो सकता है के लिए iex $_+$b
TessellatingHeckler

@TessellatingHeckler दो बाइट्स के लिए धन्यवाद!
AdmBorkBork

8

जावास्क्रिप्ट (ईएस 7), 58 57 बाइट्स

(s,t)=>s.replace(/\d+/g,n=>0|eval(n+t.replace('^','**')))

संपादित करें: जब मुझे याद आया कि replaceशाब्दिक तार पर भी काम करता है, तब 1 बाइट बचती है।


कूल, मैं ईएस 6 समाधान पर काम कर रहा हूं
बैलिंट

क्या आप एक बाइट को बचाने के लिए करी कर सकते हैं?
gcampbell

1
@gcampbell हाँ, लेकिन मैं बहुत आलसी हूँ।
नील

6

अजगर, २ ९

Jws.i:zK"\d+"3m.vs.iJ]+d;:zK1

यह मेमे से प्रत्येक संख्या को निकालकर काम करता है, और फिर .iएक स्थान के बाद इंटरलेविंग ( ) होता है और दूसरे तर्क के साथ एक सूची में लिपट जाता है। तो अगर हमारे नंबर है 7और हम था ^20हम सूची प्राप्त होगा: ["^", "7 ", "20"]। इस पर Pyth's eval( .v) को चपटा करना और उपयोग करना हमेशा वह ऑपरेशन देता है जो हम चाहते हैं। अंत में ये मान संख्याओं की घटनाओं पर मूल स्ट्रिंग विभाजन के साथ जुड़े होते हैं।

यदि दोनों इनपुट उद्धरण वर्णों से घिरे होते हैं या दो बाइट्स छोटे होते हैं तो उनमें से केवल एक को उद्धृत किया जा सकता है, यह एक बाइट कम हो सकता है।

इसे यहां आज़माएं या टेस्ट सूट चलाएं


6

पायथन 2, 156 89 88 87 बाइट्स

अन्य उत्तरों से प्रेरित होकर जो एक संचालक के साथ अपनी भाषा के प्रतिस्थापन कार्य का उपयोग करते हैं, लम्बे input स्ट्रिंग के संख्यात्मक भागों को पेरेटर के साथ oसंसाधित करते हैं। पाइथन के लिए बदकिस्मत, ^द्वारा प्रतिस्थापित किया जाना चाहिए **, जिसकी लागत 18 बाइट होती है। .group(0)कॉल बस का उपयोग करने के मैच वस्तु की स्ट्रिंग प्रतिनिधित्व चीज़ें बेहतर नहीं है ...

अनावश्यक तर्क के लिए एक शानदार स्थान और रूटट्वो को हाजिर करने के लिए QPaysTaxes का धन्यवाद .group!

import re
lambda i,o:re.sub(r'\d+',lambda p:str(eval(p.group()+o.replace('^','**'))),i)

मुझे लगता है कि आप अंतरिक्ष से छुटकारा पा सकते हैंi,o:
निक हार्टले

आप दो और बाइट्स बचा सकते हैं: (1) का उपयोग करके p.group()। (यह ० की रक्षा करता है); और (2) r=re.sub;पहले re.subकॉल को बदलें rऔर फिर r('^','**',o)इसके बजाय का उपयोग करेंo.replace(...)
RootTwo

@RootTwo: मेरे लिए, r('^','**',o)तो बचने की आवश्यकता है ^के लिए \^आदेश चरित्र, नहीं की शुरुआत से मिलान करने में o, शुद्ध नहीं बाइट्स :-( बचत - लेकिन धन्यवाद अनावश्यक ओर इशारा करते हुए के लिए 0!
ojdo

5

जावास्क्रिप्ट (ईएस 6) 99 बाइट्स

एक और उदाहरण, हम संगतता प्राप्त करने के लिए ईएस 7 का इंतजार करने से क्यों नफरत करते हैं

(a,b)=>a.match(/\d+|\D+/g).map(_=>(d=- -_)?eval(b[0]=="\^"?Math.pow(_,b.slice(1)):d+b)|0:_).join``

चल उदाहरण:

f=(a,b)=>a.match(/\d+|\D+/g).map(_=>(d=- -_)?Math.ceil(eval(b[0]=="\^"?Math.pow(_,b.slice(1)):d+b)):_).join``

alert(f(prompt("Enter string!"), prompt("Enter operation!")));


आपकी मैचिंग रेगीक्स थोड़ी दूर लगती है। रन करने योग्य उदाहरण में, आप अपरकेस अक्षरों को छोड़ देते हैं, जो उन्हें परिणाम से बाहर निकालता है ("2spooky4ME", "+1" => "3spooky5"), और पहले उदाहरण में, आप इसके विपरीत मेल खाते हैं \d+|\D+, जो इसके बराबर है .+[a-zA-Z0-9]+आप चाहते हैं regex है, नहीं? या [a-zA-Z]+|[0-9]+अगर बंटवारे से फर्क पड़ता है?
इटाई फेरबर

संभवत: Math.powसीधे-सीधे आह्वान करना आसान होगा क्योंकि आप इसे वैसे भी विशेष-मामले में ले रहे हैं। इसके अलावा, क्या आप पूर्णांक विभाजन का उपयोग कर रहे हैं?
नील

@Neil मुझे लगता है कि भूल गया, मिनट
Bálint

@ नील छत के लिए एक बेहतर तरीका है?
बैलिंट

1
@ ItaiFerber \d+|\D+के समान नहीं है .+। वे समान नहीं हैं क्योंकि क्लेने का विस्तार इससे पहले होता है or। यह वैसा ही होगा जैसा कि यह दिखता है (\d|\D)+, लेकिन जैसा है, यह 2aएक समूह में सभी का मिलान नहीं करेगा , यह दो अलग-अलग समूह होंगे।
फ्राईमई इग्मैन


4

कोटलिन, 416 413 बाइट्स

eval()कोटलिन में कमी ने वास्तव में उस बाइट की गिनती में वृद्धि की ...

fun main(a:Array<String>){var r=Regex("\\d+");var i=a[0];var n=a[1].takeLast(a[1].length-1).toInt();when(a[1][0]){'+'->print(r.replace(i,{m->""+(m.value.toInt()+n)}));'*'->print(r.replace(i,{m->""+(m.value.toInt()*n)}));'/'->print(r.replace(i,{m->""+(m.value.toInt()/n)}));'-'->print(r.replace(i,{m->""+(m.value.toInt()-n)}));'^'->print(r.replace(i,{m->""+(Math.pow(m.value.toDouble(),n.toDouble())).toInt()}));}}

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

Ungolfed

fun main(a: Array<String>) {
    var r = Regex("""\d+""")
    var i = a[0]
    var n = a[1].takeLast(a[1].length - 1).toInt()
    when (a[1][0]) {
        '+' -> print(r.replace(i, { m -> "" + (m.value.toInt() + n) }))
        '*' -> print(r.replace(i, { m -> "" + (m.value.toInt() * n) }))
        '/' -> print(r.replace(i, { m -> "" + (m.value.toInt() / n) }))
        '-' -> print(r.replace(i, { m -> "" + (m.value.toInt() - n) }))
        '^' -> print(r.replace(i, { m -> "" + (Math.pow(m.value.toDouble(), n.toDouble())).toInt() }))
    }
}

4

PowerShell (v4), 124 120 बाइट्स

# New 120 byte version:
$s,$a=$args;[regex]::Replace($s,'\d+',{($(if($a-ne($a=$a.Trim('^'))){
"$args*"*$a+1}else{"$args$a"})|iex)-replace'\..*'})

# Previous 124 byte version
$s,$a=$args;[regex]::Replace($s,'\d+',{if($a[0]-eq'^'){
[math]::pow("$args",$a.Trim('^'))}else{iex "$args$a-replace'\..*'"}})

(newlines केवल क्षैतिज स्क्रॉलिंग से बचने के लिए यहां हैं, वे एक पंक्ति के रूप में सहेजे जाने पर काम करते हैं)।

टिप्पणी, और अपुष्ट संस्करण का अनुरोध किया गया था:

$meme, $instruction = $args

# Scriptblock which processes the numbers
# to be replaced. $args is the input number.
$replacement = {

    # Generates a string of the calculation, by:
    # Removing leading ^ character, if present.
    # ^3 -> 3,      +3 -> +3
    # See if it was present, and switch code paths.
    # (Can be one combined step in the golf)
    # Switch code paths for "raise to the power of",
    # or basic arithmetic.
    $trimmedInstruction = $instruction.Trim('^')
    $tmp = if ( $instruction -ne $trimmedInstruction ) {

        # String multiplication, changes
        # function input "45" and instruction "3" into
        # "45*45*45*+1". The "3" implicitly casts to [int]
        # the +1 is there to make the trailing * not crash.
        "$args*" * $instruction + 1

    } else {
        # Cobble the basic math together as a string
        # "45" and "+10" becomes
        # "45+10"
        "$args$instruction"
    }

    # eval() the generated string (e.g. "45+10" or "45*45*45*+1")
    $tmp = Invoke-Expression $tmp      # iex

    # Use a regex golf to replace trailing .23423
    # decimals in case of division with remainder.
    # Acts as [math]::floor(), harmless on other numbers.
    $tmp -replace'\..*'
}

# A regular expression replacement which picks out all 
# the numbers (\d+) and runs them through the
# replacement function. Returns a string which 
# ends up on stdout
[regex]::Replace($meme, '\d+', $replacement)
  • .Net रेगेक्स लाइब्रेरी एक स्क्रिप्टब्लॉक के साथ एक जगह ले सकता है जो मैच की सामग्री पर अमल करता है, और पावरशेल संख्याओं के लिए तार टाइप करता है, और अन्य भाषाओं की iexतरह eval()है। यह सिर्फ करता है "2spooky" "+3"->eval("2+3")
  • सिवाय ... यह ^ऑपरेटर या किसी अन्य सुविधाजनक घातांक को संभाल नहीं सकता है **, यह केवल [math]::Pow()पुस्तकालय कॉल का उपयोग कर सकता है इसलिए उस शाखा को संभालने के लिए एक बड़ा ब्लॉक है।
    • अपडेट किया गया संस्करण @TimmyD से एक आइडिया चुराता है और इसके बजाय स्ट्रिंग गुणन करता है - "2*" * nजो बन जाता है "2*2*2*2*"और फिर +1अनुगामी के बारे में शिकायत करने के बजाय एक के बाद एक को गुणा करता है *
  • सिवाय ... .नेट बैंकर के राउंडिंग करता है जो डिफ़ॉल्ट रूप से निकटतम सम संख्या में गोल होता है, और 3/2 = 1. के बजाय 3/2 = 2। यह चुनौती ट्रंकेशन के लिए कॉल करता है, और इसका मतलब है [math]::Truncate()। इसके बजाय, मैं -replaceएक दशमलव बिंदु और उसके बाद कुछ भी ट्रिम करने के लिए वर्णों को सहेजता हूं ।

परीक्षण के मामलों:

PS D:\> .\meme.ps1 2spooky4me +1
3spooky5me

PS D:\> .\meme.ps1 2spooky4me -1
1spooky3me

PS D:\> .\meme.ps1 2spooky4me *15
30spooky60me

PS D:\> .\meme.ps1 10spooky900me /5
2spooky180me

PS D:\> .\meme.ps1 idontunderstandememes3 /2
idontunderstandememes1

PS D:\> .\meme.ps1 "idontunderstandememes3" "/2"
idontunderstandememes1

PS D:\> .\meme.ps1 "notreallyafunnymeme" "*100"
notreallyafunnymeme

PS D:\> .\meme.ps1 "2spooky4me" "^3"
8spooky64me

PS D:\> .\meme.ps1 "some1meme2sequences3can4be5really6long7" "/2"
some0meme1sequences1can2be2really3long3

PS D:\> .\meme.ps1 2000000000000000000000000000000000000000000000000000000000000000000000000000000‌​000000000000000000000000000000000spooky4me /2
1E+78‌​0spooky2me

एनबी। अंतिम परीक्षण में संख्याएँ [BigInteger]अपने आप टाइप हो जाती हैं, लेकिन वे वैज्ञानिक संकेतन में प्रस्तुत हो जाती हैं। सौभाग्य से, सितारों के बीच संवाद करने में सक्षम हर ज्ञात दौड़ में पर्याप्त वैज्ञानिक विकास है जो समस्या के बिना वैज्ञानिक संकेतन को संसाधित करने में सक्षम है।


1
आप अन्य उत्तरों में देख सकते हैं कि वे कोड व्यवहार की जांच के लिए कैसे एक अपठनीय गोल्फ संस्करण प्रदान करते हैं और फिर एक अलग-अलग ungolfed संस्करण। आपको यह आपके साथ करना चाहिए (अर्थात्, गोल्फ संस्करण में नई प्रतियां हटा दें)।
jpmc26

क्रेडिट के लिए धन्यवाद, लेकिन मेरी चाल नहीं - मैंने इसे पॉवरशेल टिप्स थ्रेड से खींच लिया।
AdmBorkBork

जाहिर है, मैं एक टिप्पणी छोड़ने के लिए पर्याप्त देखभाल करता हूं, और कोई और मेरी टिप्पणी को आगे बढ़ाने के लिए पर्याप्त परवाह करता है। ;)
jpmc26

नहीं, मैंने कहा कि आपके पास एक पूरी तरह से गोल्फ संस्करण और एक पूरी तरह से ungolfed संस्करण होना चाहिए। गोल्फ वाले को स्क्रॉल करने की आवश्यकता होगी। अपराजित व्यक्ति आपके पास जितना होगा, उससे अधिक पठनीय नहीं होगा।
jpmc26

1
@ jpmc26 ठीक है, मैंने एक अनगढ़, टिप्पणी वाले संस्करण में संपादित किया है।
TessellatingHeckler

3

बैश + जीएनयू कोरुटिल्स, 144 बाइट्स

d=
u=$1,
for((i=0;i<${#u};i++)){ l=${u:i:1}
[[ "$l" =~ [0-9] ]]&&d=$d$l||{ [ -z $d ]||echo -n `bc<<<$d$2`&&{ [ $l != , ]&&echo -n $l; };d=; }
}

यह अंकों और गैर-अंकों के बीच परिवर्तन को देखता है, इसीलिए इनपुट स्ट्रिंग में एक यादृच्छिक अमान्य इनपुट चरित्र (अल्पविराम) जोड़ा जाता है। इस कॉमा को तब आउटपुट में अनदेखा किया जाता है। ओपी का अधिवेशन ठीक उसी प्रकार होता है, bcजैसा कि गणित को करने के लिए यहां वाक्य विन्यास का होता है।


वैसे @TessellatingHeckler द्वारा PowerShell-solution में चर्चा के कारण: मेरे समाधान में, आप अर्ध विराम पर लाइन विराम को प्रतिस्थापित करके कार्यक्रम को एक पंक्ति में अनुवाद कर सकते हैं, जिससे इसकी लंबाई नहीं बदलती।
रेक्सकोगिटंस

3

लुआ, 145 93 बाइट्स

r=io.read;m=r()o=r()m=m:gsub("%d",function(n)return loadstring("return..."..o)(n)end)print(m)

सिर्फ एक समारोह क्यों नहीं?
बैलिंट

2

आर, 163 बाइट्स

आर में नियमित अभिव्यक्ति और स्ट्रिंग प्रतिस्थापन में सीखने वाले किसी व्यक्ति के रूप में, यह एक काफी कठिन चुनौती साबित हुई। विशेष रूप से क्योंकि संख्याओं का मिलान आसान है, लेकिन मुझे एक से अधिक प्रतिस्थापनों का उपयोग करने का तरीका नहीं मिला gsub। इसके अलावा, मुझे नहीं पता कि eval(parse(paste0(...संचालन के बीच स्विच करने का सबसे कुशल तरीका क्या है। हो सकता है कि switch-function यहाँ बेहतर अनुकूल है।

function(s,o){p=strsplit;y=p(gsub("\\d+","?",s),"?")[[1]];x=na.omit(as.integer(p(s,"[a-zA-Z]+")[[1]]));y[y=="?"]=floor(eval(parse(,,paste0("x",o))));cat(y,sep="")}

व्याख्या

f=function(s,o){
    p=strsplit                                    # alias for stringsplit    
    y=p(gsub("\\d+","?",s),"?")[[1]]              # substitute numbers with "?" and split into vector on "?"
    x=na.omit(as.integer(p(s,"[a-zA-Z]+")[[1]]))  # split at alphabetical char, return vector with numbers to be operated on
    y[y=="?"]=floor(eval(parse(,,paste0("x",o)))) # replace inserted "?" with vector of numbers operated on
    cat(y,sep="")                                 # print concatenated vector
}

मुझे लगता है कि यदि आप मैचों पर एक बंद के साथ gsub का उपयोग करते हैं, तो आप एक टन बाइट्स बचा सकते हैं, जो आपने अपनी टिप्पणी में संकेत दिया था। मुझे नहीं पता कि आर में इसे कैसे करना है। जब तक मुझे पता नहीं चला कि मैं ग्रूवी में ऐसा कैसे करूं; बहुत ज्यादा गेम चेंजर था।
मैजिक ऑक्टोपस Urn

2

जावास्क्रिप्ट (ईएस 6), 85 बाइट्स

x=(s)=>{var a=s.split(" ");return[...a[0]].map(x=>(!isNaN(x))?eval(x+a[1]):x).join``}

console.log(x("2spookie5me +1"));

Ungolfed:

x = (s) => {
  var a = s.split(" ");
  return [...a[0]].map(x => (!isNaN(x)) ? eval(x + a[1]) : x).join ``
}
console.log(x("2spookie5me +1"));

किसी को पता है अगर मैं स्प्रेड ऑपरेटर का उपयोग करके रिक्त स्थान को विभाजित कर सकता हूं? इस s.split ("") से; को ["" ... एस]; कम से कम इस विचार पर विचार करता है।
ब्लादिमीर रुइज

आपको ()लैम्ब्डा तर्क के आसपास की आवश्यकता नहीं है, आपको ज़रूरत नहीं है var, और आपको ब्रेसिज़ के बजाय return
पार्न्स

इसके अलावा, ^जावास्क्रिप्ट के लिए एक विशेष मामला है, यह एक बिटव्यू एक्सओआर के बजाय हैMath.pow
सनी पुण

2

ग्रूवी, 64 60 बाइट्स

{a,b->a.replaceAll(/\d+/,{Eval.me(it+b.replace("^","**"))})}

पारित अंकों के सभी उदाहरणों को एक क्लोजर के साथ बदल देता है जो पास किए गए शब्द के अंक भागों पर ऑपरेशन का मूल्यांकन करता है। यदि एक घातांक फ़ंक्शन पारित किया गया है, तो वह इसे उचित अंकन के साथ बदल देता है। Groovy अंतर्निहित रूप से BigInteger / BigDecimal रूपांतरण का उपयोग करता है, Eval.me()क्योंकि पार्स किए गए तार संभवतः 2^32-1सीमा से बाहर हो सकते हैं ।

व्याख्या की

{a,b->...} - दो तर्कों के साथ बंद।

a.replaceAll(/\d+/,{...}) - स्ट्रिंग में सभी अंक अनुक्रमों के लिए खोजें और एक क्लोजर के साथ बदलें।

{Eval.me(it+b.replace("^","**"))} - अधिक विशेष रूप से, ऑपरेशन से जुड़े प्रत्येक मैच के साथ एक निकटता, फिर ग्रूवी कोड के रूप में मूल्यांकन किया गया।

.replace("^","**")- प्रदान किए गए ऑपरेशन में ^ग्रूवी एक्सपोर्टर ऑपरेटर के साथ पहले उदाहरण को बदलें **। यदि आप चाहते हैं कि यह पूर्ण समीकरण स्ट्रिंग्स के साथ काम करे, जो घातांक का उपयोग replaceAll()करते हैं, तो +3 बाइट दंड के लिए उपयोग करें ।

फन साइड-नोट उसका एक वैध परीक्षण परिदृश्य है:
(22348952345238905290858906209862398036spooky409552me, /200*4943^8-23939+((100/203)+600)


1

RProgN , 39 बाइट्स

►x='%d+'§x'%D+'''Rx'%d+'''Rg'y'=y_}R

व्याख्या की

►x='%d+'§x'%D+'''Rx'%d+'''Rg'y'=y_}R
►                                       # Spaceless segment.
 x=                                     # Assign the top value of the stack '[+*/-]\d+' 
   '$d+'§                         }R     # Replace everything in the pattern %d+ (all numbers) based on an anonymous function 
         x'%D+'''R                      # Replace all Non-digits in the modifer with nothing, leaving just the second argument for the operator.
                  x'%d+'''R             # Snip all digits, separating our operator from our digits such that digit operator exists in the stack.
                           g'y'=        # Grab the function that is represented by the top of the stack (the operator in this case)
                                y       # Run it
                                 _      # Floor the result. 

तकनीकी रूप से अमान्य उत्तर, क्योंकि यह भाषा इसके लिए मौजूद नहीं थी। हालांकि, इसे विशेष रूप से इसके लिए तैयार नहीं किया गया था, न ही कोई विशेष जोड़। इसलिए मैं इसे चला रहा हूं। मेरे पर मुकदमा कर दो।

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


0

पर्ल 6, 111 बाइट्स

{/(\w+)\s(<[+\-*/^]>)(\d+)/&&my \b=+$2;my \o=(*+b,*-b,* *b,*div b,* **b)[index "+-*/^",$1];$0.subst(/\d+/,o):g}

दुर्भाग्य EVALसे डिफ़ॉल्ट रूप से अक्षम है। इसके अलावा, आपको divपूर्णांक विभाजन के लिए उपयोग करना होगा।

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