एक माउस डायनामाइट के साथ

तुम एक चूहे हो। आपके माउस मित्र सभी को पकड़ लिया गया है, और बेहोश हो गए हैं और एक चक्रव्यूह में फंस गए हैं जिसमें केवल एक ही प्रवेश / निकास है। आपके पास भूलभुलैया का एक आदर्श नक्शा है, इसलिए आप सभी को सुरक्षा के लिए अंदर ले जाने के लिए एक समाधान तैयार कर सकते हैं। हालांकि, भूलभुलैया को एक सुरक्षा प्रणाली के साथ संरक्षित किया गया है जो कि अगर एक सीमा 1000तक पहुंच जाती है, तो एक चेतावनी को ट्रिगर करेगा , जिससे आपको कब्जा कर लिया जा सकता है और आपके बचाव मिशन को विफल कर सकता है।

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

आपके पास डायनामाइट की असीमित आपूर्ति है जिसे आप प्रवेश द्वार पर लाए हैं, ताकि आप अपने दोस्तों को मुक्त करने के लिए सभी दीवारों को उड़ा सकें । लेकिन आपको ऐसा करने से सतर्क रहने की जरूरत है, क्योंकि प्रत्येक विस्फोट 50, समवर्ती दबाव से काउंटर में जुड़ जाता है। इसके अतिरिक्त, आप केवल एक समय में एक माउस या डायनामाइट के एक ब्लॉक को ले जा सकते हैं। चूंकि डायनामाइट का प्रत्येक ब्लॉक केवल एक दीवार स्थान को विस्फोट कर सकता है, इसका मतलब है कि यदि एक पंक्ति में कई दीवारें हैं, तो आपको अधिक को हथियाने के लिए प्रवेश के लिए खाली हाथ यात्रा करने की आवश्यकता है।

काम के माध्यम से उदाहरण

मान लीजिए कि हमारा चक्रव्यूह निम्नलिखित की तरह दिखता है:

######
#M# E#
######

मैं cकाउंटर के लिए उपयोग करूंगा । हम पर शुरू Entrance, एक वर्ग बाईं को स्थानांतरित करते हुए बारूद ले जाने, c=2। हम, डायनामाइट विस्फोट दीवार विस्फोट के लिए c=52। हम दो वर्गों को खाली छोड़ देते हैं, खाली हाथ, पाने के लिए c=54, और हम अब माउस के वर्ग पर खड़े हैं। हम अपने दोस्त को उठाते हैं, और 3 वर्गों को वापस Eएक्सिट में ले जाते हैं, लेकिन अंतिम वर्ग की गिनती नहीं होती है क्योंकि इसमें कोई सेंसर नहीं है, इसलिए हमारी पीठ पर कुछ के साथ केवल 2 वर्ग हैं। इसका मतलब है कि जब हम अंतिम माउस के साथ निकास तक पहुंचते हैं c=58, जो कि कम है 1000, और इसलिए मिशन सफल होता है।

चुनौती

एक इनपुट भूलभुलैया, आउटपुट को देखते हुए कि क्या आप, माउस हीरो, ऊपर उल्लिखित बाधाओं के भीतर फंसे हुए चूहों को सफलतापूर्वक बचा सकते हैं, या फिर मिशन विफल है या नहीं।

इनपुट

किसी भी स्वीकार्य प्रारूप में एक 2 डी भूलभुलैया (बहुस्तरीय स्ट्रिंग, तार की सरणी, आदि)।
इस चुनौती के लिए, मैं #आंतरिक और बाहरी दोनों दीवारों के Mलिए, माउस मित्रों के लिए, और Eप्रवेश द्वार के लिए उपयोग करूंगा ।
प्रवेश द्वार तुरंत एक आंतरिक दीवार से सटे नहीं होगा (इसमें हमेशा कम से कम एक स्थान होगा जिसमें स्वतंत्र रूप से स्थानांतरित करना होगा)।
आप किसी भी मुद्रण योग्य ASCII वर्णों को तब तक स्थानापन्न कर सकते हैं, जब तक आप इसके अनुरूप हों। यह करता है , तो आप भीतरी दीवारों बनाम बाहरी दीवारों के लिए दो अलग-अलग प्रतीकों का उपयोग करने की अनुमति इतने लंबे समय के रूप में आप स्थिरता (जैसे, आप का उपयोग करना चाहते हैं बनाए रखने के @बजाय भीतरी दीवारों के लिए, और छुट्टी #के बाहरी हिस्से का, हर आंतरिक दीवार होना चाहिए @और हर बाहरी दीवार #)।
भूलभुलैया हमेशा पूरी तरह से दीवारों से घिरा होगा, लेकिन जरूरी नहीं कि आयताकार हो। यदि वांछित है, तो आप मान सकते हैं कि आयताकार इनपुट (वैकल्पिक) बनाने के लिए रिक्त स्थान के साथ भूलभुलैया गद्देदार है।
भूलभुलैया में ऐसे अनुभाग हो सकते हैं जो डायनामाइट के बिना पहुंच से बाहर हैं।
आप भूलभुलैया की बाहरी दीवारों को डायनामाइट नहीं कर सकते।

उत्पादन

एक सच्चाई / गलत मूल्य। "हाँ, माउस हर दूसरे माउस को छुड़ा सकता है" या "नहीं, अलार्म सिस्टम को टाल दिया जाएगा।"

नियम

या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं।
मानक खामियों को मना किया जाता है।
यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

सत्य उदाहरण, कोरी लाइनों द्वारा अलग किया गया।

#####
#M E#
#####

######
#M# E#
######

########
#E  # M#
#   #  #
#   #  #
#      #
########

#############################
#    ##      #       #      #
#  M ## M    #       #      #
#    ##      #   M   #    E #
#M   ##      #       #      #
#############################

###############
#MMMMMMMMMMMMM#
#MMMMMMMMMMMMM#
#MMMMMMMMMMMMM#
#MMMMMMMMMM MM#
#MMMMMMMMMMMME#
###############

झूठा उदाहरण, रिक्त लाइनों द्वारा अलग किया गया

#############################
#M   ##      ##      ##     #
#  M ## M    ##      ##     #
#    ##      ##  M   ##   E #
#M   ##      ##      ##     #
#############################
#############################
                     ########
                     ########
                     #   #  #
                     # M # M#
                     ########

              #####
              # M #
              #####
              #####
              #####
              #####
###################
# # # ##   ## # # #
#M#M#M## E ##M#M#M#
# # # ##   ## # # #
###################
#######
######
#####
####
# M#
####

###############
#MMMMMMMMMMMMM#
#MMMMMMMMMMMMM#
#MMMMMMMMMMMMM#
#MMMMMMMMMMMMM#
#MMMMMMMMMMMME#
###############

code-golf path-finding maze

— AdmBorkBork
स्रोत

चूहे उग्र (हल्के बिगाड़ने वाले) थे

— लुइस मेन्डो

@AlexA। क्षमा करें कि आपको इसे इंटरनेट पर किसी अजनबी से सीखना था। ;-)

— AdmBorkBork

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

— मोशे काट्ज़

क्या बाहरी दीवारों के लिए एक अलग चार होना स्वीकार्य है (क्योंकि वे अस्थिर नहीं हैं)?

— तनीसबाई

@ मोशे काट्ज , सुनिश्चित करें कि आपके पास समय नहीं है। तुम बस Mäuse को बचाना नहीं चाहते।

— msh210 18

जवाबों:

पर्ल, 216 215 बाइट्स

के लिए +2 शामिल है -0p

STDIN पर इनपुट दें। का प्रयोग करें %बाहरी दीवारों के लिए, #आंतरिक दीवारों के लिए, 0खाली स्थान के लिए, 8चूहों के लिए और rप्रारंभिक स्थिति के लिए। पूरे बोर्डों को पैडेड किया जाना चाहिए ताकि यह एक आयत बन जाए। आप उदाहरणों को बदल और चला सकते हैं:

cat dynamite.txt | perl -p0e 's/.+/$a^=$&/egr;s//sprintf"%-*s",length$a,$&/eg;1while/\n/,s/^ *\K#|#(?= *$)|^ *.{@{-}}\K#|\A[^\n]*\K#|#(?=[^\n]*\n\z)|#(?=.{@{-}} *$)/%/sm;y/ EM/0x2/' | dynamite.pl

dynamite.pl:

#!/usr/bin/perl -0p
sub f{@a{@_}||=push@{$%+($&?$1?50:$&=~8?0:$&&"5"?2:1:0)},@_}f$_;for(@{$%}){f y/xr|/ytx/r;{f s/\pL\d/$&^(E&$&)x2/er}{f s/(q|s|y)#/$&^"\x01\x13"/er}my$o;{$\|=/x/>/2/;$o.="
"while s/.$/$o.=$&,""/meg}f$o}$%++>999|$\||redo}{

\xhhदावा किए गए स्कोर के लिए पलायन को बदलें ।

कार्यक्रम वास्तविक रूप से जटिल मामलों को संभाल नहीं सकता है। विशेष रूप से यह किसी भी विफलता के मामलों को संभाल नहीं सकता है। इसका कारण यह है कि आंतरिक दीवारों को उड़ाने या चूहों को लेने के कई अलग-अलग तरीके हैं इसलिए खोज बहुत व्यापक हो जाती है और बहुत अधिक मेमोरी का उपयोग करती है, भले ही यह कम से कम इतना स्मार्ट हो कि एक ही राज्य को कई बार संसाधित न कर सके। दबाव सीमा को 100कुछ हद तक बीरबल रनटाइम और मेमोरी उपयोग के लिए या तो कम करना पड़ता है ।

व्याख्या

मैं एक क्षेत्र की स्थिति का प्रतिनिधित्व करने के लिए एक चरित्र के बिट पैटर्न का उपयोग करता हूं:

contains victim: 0000 0010
has hero:        0100 0000
carry dynamite   0000 0001
carry mouse      0000 0100
home             0000 1000
walkable         0001 0000 (not really needed but results in shorter regexes)
make printable   0010 0000
wall             0010 xxxx (bit patterns not very important,
permawall        0010 xxxx  just avoid letters and digits)

उदाहरण के लिए हीरो ( 01000000) डायनामाइट ले जाने वाला ( 00000001) ऐसी जगह पर होना चाहिए जहां वह चल सके ( 00010000) और हम चाहते हैं कि सभी मान मुद्रण योग्य ASCII ( 00100000) हों। orइन सभी बिटकॉम्स का बिटवाइज़ लेना 01110001जो कि ASCII कोड है, के लिए देता है q। कुल मिलाकर यह ::

p: hero                     r hero on victim
q: hero carrying dynamite   s hero carrying dynamite on victim
t: hero carrying mouse      v hero carrying mouse on victim

x : hero at home
y : hero at home carrying dynamite
| : hero at home carrying mouse

0: empty  without hero
8: home   without hero
2: victim without hero

%: permanent wall
#: normal wall

कार्यक्रम केवल नायक को दाईं ओर ले जाने पर विचार करेगा (बाद में समझाया गया रोटेशन अन्य दिशाओं का ध्यान रखेगा)। बिटकॉम्स को सावधानीपूर्वक चुना गया था कि नायक को हमेशा एक पत्र द्वारा दर्शाया जाता है और एक स्थान जिसे वह एक अंक द्वारा स्थानांतरित कर सकता है (घर पर नायक को शिकार को छोड़कर, लेकिन फिर भी यह जानबूझकर होता है ताकि नायक का एकमात्र कदम गिर जाए शिकार)। तो एक नायक जो आगे बढ़ सकता है, वह मेल खाता है /\pL\d/। मिलान किए गए विकल्प को संशोधित किया जाना चाहिए ताकि नायक और जो वह ले जा रहा है उसे पहले चरित्र से हटा दिया जाए और दूसरे में जोड़ा जाए, जो xorदोनों वर्णों के लिए समान मूल्य के साथ एक बिटवाइज़ के साथ किया जा सकता है । एक्सर मूल्य में हीरो बिट ( 01000000), डायनामाइट बिट ( 00000001) और कैरी माउस बिट ( 00000100) होते हैं। वे एक साथ orकरने के लिए01000101जो ASCII है E। तो नायक के चलते यह हो जाता है:

s/\pL\d/$&^(E&$&)x2/e

नायक एक दीवार को उड़ाने वह इसे के सामने सही खड़ा करता है, तो जाता है और बारूद ले जा रहा है (कर सकते हैं q, sया y)। नायक अपना डायनामाइट ( xorसाथ 00000001) खो देगा और दीवार #एक मार्ग 0(xor के साथ 00010011) में बदल जाएगी , इसलिए

s/(q|s|y)#/$&^"\x01\x13"/e

अन्य दिशाओं को संभालने के लिए पूरे बोर्ड को घुमाया जाता है (घुमाया बोर्ड समाप्त होता है $o):

my$o;$o.="\n"while s/.$/$o.=$&,""/meg

नायक को स्थानांतरित करने के अलावा उसके पास कई अन्य विकल्प भी हो सकते हैं:

When at home, pick up dynamite:                   x -> y
When on victim not carrying anything pick him up: r -> t
When at home carrying a victim, drop him off:     | -> x

इसके द्वारा किया जाता है

y/xr|/ytx/

बोर्ड खत्म हो गया है अगर नायक कुछ भी नहीं ले रहा है ( x) और बचाव के लिए और अधिक पीड़ित नहीं हैं (नहीं 2)। इसका उपयोग करके आसानी से परीक्षण किया जा सकता है

/x/>/2/

एक बार बोर्ड हल हो जाने के बाद मैं इस राज्य को याद रखना चाहता हूं और अंत में इसे प्रिंट करना चाहता हूं। उसके लिए मैं "हल किया गया" झंडा अंदर ले जाता हूं $\और प्रिंट के बिना कार्यक्रम के अंत में प्रिंट करता हूं $_, इसलिए

$\|=/x/>/2/  ...   }{

दबाव 0 पर संसाधित किए जाने वाले राज्यों को @01 पर @1दबाव में रखा जाता है $%। वर्तमान दबाव में रखा जाता है । इसका उपयोग करना $nया ऐसा कुछ करना कम होगा, लेकिन कोड काम नहीं करता है यदि चर को किसी चीज के लिए आरंभीकृत नहीं किया जाता है, क्योंकि स्वतः-एकीकरण अन्यथा $nएक ARRAY संदर्भ में बदल जाएगा । एक निश्चित दबाव पर राज्यों पर लोड करना एक का उपयोग करके किया जाता है forऔर mapइसलिए नहीं एक साथ for, जबकि यह अभी भी अधिक लूप में चलाया जा रहा है आप सरणी का विस्तार कर सकते हैं और नए तत्वों को लेने होंगे। इसकी आवश्यकता है क्योंकि घुमाव और नायक के एकल क्षेत्र विकल्प 0 समय में होते हैं और एक ही दबाव सरणी में समाप्त होते हैं। तो दिए गए दबाव के लिए लूप द्वारा किया जाता है

for(@{$%}){...}

यह तब तक दोहराया जाता है जब तक कि दबाव 1000 तक नहीं पहुंच जाता या समाधान नहीं मिल जाता:

$%++>999|$\||redo

जो कुछ बचा है वह नए खोजे गए राज्यों को उनके संबंधित दबाव सरणियों में जोड़ रहा है। जो कि सबरूटीन द्वारा किया जाएगा f। हम केवल एक राज्य जोड़ना चाहते हैं यदि यह अभी तक नहीं देखा गया है। जिन राज्यों को पहले देखा जा चुका है उन्हें इसमें रखा गया %aहै:

sub f{@a{@_}||=push@$n, @_}

$nएक राज्य के लिए नए दबाव का प्रतिनिधित्व करता है। मुझे लगता है कि राज्य से regex चर अभी भी नायक के इस फोन करने के लिए अग्रणी कार्रवाई के परिणामस्वरूप होगा:

if $1 is set it was from s/(q|s|y)#/$&^"\x01\x13"/e which blows a wall -> 50
else if $& is set it was from s/\pL\d/$&^(E&$&)x2/e, so the hero moves.
    if $& contains 8 the hero went home -> 0
    else if the hero has carry bits (5) -> 2
    else                                   1
else ($& was not set) it was from y/xr|/ytx/r -> 0

यह निम्न सूत्र की ओर जाता है $n:

$%+($&?$1?50:$&=~8?0:$&&"5"?2:1:0)

सभी प्रतिस्थापनों को एक rसंशोधक मिलता है इसलिए वे बदले हुए राज्य को वापस करते हैं और वर्तमान स्थिति को $_अकेले छोड़ देते हैं। fफिर इस परिवर्तित स्थिति पर कॉल किया जाता है, इसलिए आपको कोड पसंद आता है

f y/xr|/ytx/r;

क्योंकि $nरिजेक्स वैरिएबल की जरूरतों की गणना करने के लिए उन्हें डिफ़ॉल्ट होना चाहिए, यदि प्रतिस्थापन कुछ नहीं बदलता है (क्योंकि उन्हें ट्रिगर करने की शर्त पूरी नहीं होती है)। मुझे पिछले लूप से कोई भी रेगेक्स वैरिएबल नहीं लेना चाहिए। इसलिए {}regex स्थिति को बचाने और पुनर्स्थापित करने के लिए प्रतिस्थापन को ब्लॉकों में लपेटा जाता है । इसी तरह आपको स्टेटमेंट मिलते हैं

{f s/\pL\d/$&^(E&$&)x2/er}

विशेष रूप से रोटेशन इतना लपेटा हुआ है कि यह fरेगेक्स चर के बिना कॉल करता है और 0 का दबाव योगदान देता है।

अभी भी केवल एक चीज है @0जो शुरुआत में प्रारंभिक स्थिति के साथ अभाज्य है

f$_

यह मुख्य लूप में है इसलिए यह $_बाद में दबाव सरणियों को जोड़ने का भी प्रयास करता है , लेकिन चूंकि प्रारंभिक स्थिति पहले से ही %aकुछ भी नहीं होगी।

यह सब एक साथ मूल रूप से डीजकस्ट्रा के एल्गोरिथ्म का उपयोग करते हुए सबसे छोटा समाधान पाता है । हालांकि एक संभावित समस्या है। वर्तमान कोड पहली खोज की तुलना में कम दबाव के साथ फिर से खोजे जाने पर एक स्थिति नहीं जोड़ेगा। मैं एक बोर्ड का निर्माण करने में सक्षम नहीं हूं जो इसे ट्रिगर करेगा, लेकिन यह साबित करने में भी असमर्थ है कि यह असंभव है।

— टन हास्पेल
स्रोत

ऊ, लुभावना। यह किसी भी उत्तर होने की अपेक्षा से काफी कम है। क्या आप थोड़ा सा स्पष्टीकरण जोड़ सकते हैं? मैं वास्तव में पर्क नहीं मारता।

— AdmBorkBork

@ टिम्मीड ओके, स्पष्टीकरण पर्याप्त विवरणों के साथ जोड़ा गया है ताकि एक गैर पर्ल प्रोग्रामर को भी कम से कम यह पता

— चले

बहुत प्रभावशाली!

— एमिग्ना

बहुत बढ़िया गोल्फ, यह वास्तव में प्रभावशाली है ... जब मुझे लगता है कि मैं पर्ल के साथ गोल्फ में बुरा नहीं हूं, तो मैं आपके गोल्फ पर एक नज़र डालता हूं, और यह भावना बहुत तेजी से दूर हो जाती है!

— दादा

जावास्क्रिप्ट, 863 834 785 781 बाइट्स

जॉर्डन के लिए 53 बाइट्स सहेजे गए ETHproductions के लिए 29 बाइट्स सहेजे गए

L=[]
f=(S,r="",R="",p=0,s=S.replace(RegExp(r),R),l=`((.|\n){${s.split`
`[0].length}})`,q=p+1,o=p+2,n=p+50)=>s in L|p>999?1e3:!/M/.test(s,L[s]=0)&/E/.test(s)?p:Math.min(...[[/ E/,"me",q],[/ E/,"de",o],[/ME/,"ce",q],[/E /,"em",q],[/E /,"ed",o],[/EM/,"ec",q],[`E${l} `,"e$1m",q],[`E${l} `,"e$1d",o],[`E${l}M`,"e$1c",q],[` ${l}E`,"m$1e",q],[` ${l}E`,"d$1e",o],[`M${l}E`,"c$1e",q],[/ m/,"m ",q],[/m /," m",q],[`m${l} `," $1m",q],[` ${l}m`,"m$1 ",q],[/ (d|c)/,"$1 ",o],[/(d|c) /," $1",o],[`(d|c)${l} `," $2$1",o],[` ${l}(d|c)`,"$3$1 ",o],[/d#/,"m ",n],[/#d/," m",n],[`#${l}d`," $1m",n],[`d${l}#`,"m$1 ",n],[/mM/," c",q],[/Mm/,"c ",q],[`M${l}m`,"c$1 ",q],[`m${l}M`," $1c",q],[/[mc]e/," E",p],[/e[mc]/,"E ",p],[`e${l}[mc]`,"E$1 ",p],[`[mc]${l}e`," $1E",p]].map(a=>f(s,...a)))
F=s=>f(s)<1e3

मल्टीलाइन स्ट्रिंग के रूप में इनपुट लेता है।

यह एक अनाम फ़ंक्शन को परिभाषित करता है, जो यह निर्धारित fकरने के लिए पुनरावर्ती फ़ंक्शन का उपयोग करता है कि क्या आप सभी चूहों को प्राप्त करने से पहले अलार्म बंद कर देते हैं। यदि fरिटर्न 10001000 से ऊपर है (अंतहीन पुनरावृत्ति से बचने के लिए), तो दबाव लौटाता है यदि बचाव और माउस से बाहर निकलने के लिए कोई अधिक चूहे नहीं हैं, और वर्तमान स्थिति से सभी संभावित चालों का न्यूनतम दबाव अन्यथा वापस कर देता है। यह Lपहले से ही देखी गई स्थितियों का ट्रैक रखने के लिए एक सरणी का उपयोग करता है जहां L[pos]==0अगर यह दौरा किया जाता है, और अपरिभाषित नहीं है तो यह नहीं है। यह आवश्यक नहीं हो सकता है, लेकिन यह माउस को बेकार चालों और पुनरावृत्ति त्रुटियों को कम से कम करने से रोकता है। (इसका मतलब है कि Lयदि आप कई बार परीक्षण कर रहे हैं तो आपको इसे फिर से परिभाषित करना चाहिए )

यह प्रश्न के अलावा प्रारूप का उपयोग करता है इसके लिए आपको बाहरी दीवारों के लिए एक अलग चरित्र का उपयोग करना होगा। (इसके अलावा कुछ भी # MEmecd)

अधिक पठनीय संस्करण:

stateList = []
f=(s,regex="",replacement="",pressure=0,state=s.replace(regexp(regex),replacement),line=`((.|\n){${state.split("\n")[0].length}})`)=>{
    if (state in stateList || pressure > 999) return 1e3
    if (!/M/.test(state) && /E/.test(state)) return pressure

    stateList[state] = 0

    return [
        [/ E/,"me",pressure+1],
        [/ E/,"de",pressure+2],
        [/ME/,"ce",pressure+1],
        [/E /,"em",pressure+1],
        [/E /,"ed",pressure+2],
        [/EM/,"ec",pressure+1],
        [`E${line} `,"e$1m",pressure+1],
        [`E${line} `,"e$1d",pressure+2],
        [`E${line}M`,"e$1c",pressure+1],
        [` ${line}E`,"m$1e",pressure+1],
        [` ${line}E`,"d$1e",pressure+2],
        [`M${line}E`,"c$1e",pressure+1],
        [/ m/,"m ",pressure+1],
        [/m /," m",pressure+1],
        [`m${line} `," $1m",pressure+1],
        [` ${line}m`,"m$1 ",pressure+1],
        [/ ([dc])/,"$1 ",pressure+2],
        [/([dc]) /," $1",pressure+2],
        [`([dc])${line} `," $2$1",pressure+2],
        [` ${line}([dc])`,"$3$1 ",pressure+2],
        [/d#/,"m ",pressure+50],
        [/#d/," m",pressure+50],
        [`#${line}d`," $1m",pressure+50],
        [`d${line}#`,"m$1 ",pressure+50],
        [/mM/," c",pressure+1],
        [/Mm/,"c ",pressure+1],
        [`M${line}m`,"c$1 ",pressure+1],
        [`m${line}M`," $1c",pressure+1],
        [/[mc]e/," E",pressure],
        [/e[mc]/,"E ",pressure],
        [`e${line}[mc]`,"E$1 ",pressure],
        [`[mc]${line}e`," $1E",pressure]
    ].map(a=>f(state,...a)).reduce((a,b)=>a-b<0?a:b) //reduce used for support in more browsers.
}
s=>f(s)>1e3

— DanTheMan
स्रोत

बेकार व्हाट्सएप पर s in L|p > 999।

— यति

@TuukkaX मुझे उस बारे में याद दिलाने के लिए धन्यवाद, बाइटकाउंट पहले से ही रिक्त स्थान के बिना संस्करण के लिए था।

— डैनमैन मैन 24/16

देखें कि क्या आप कोड को लपेटकर evalऔर उसके @साथ प्रतिस्थापित करके बाइट्स बचा सकते हैं $1(यह सुनिश्चित करने के लिए कि यह काम करेगा, लेकिन आप $1बहुत कुछ लिखते हैं )

— Cycece

मुझे लगता है कि आप fवन-लाइनर बनाकर एक गुच्छा बचा सकते हैं:f=(...)=>s in L|p>999?1e3:!/M/.test(s,L[s]=0)&/E/.test(s)?p:Math.min(...

— ETHproductions

@ मुझे लगता है कि $118 बार का उपयोग करें , और .replace("@","$1")18 बाइट्स है। मुझे इसे खींचने का कोई रास्ता नहीं दिख रहा है।

— DanTheMan