एक अस्सी-आर्ट रोड और मुझे इसे पार करने में लगने वाले समय को देखते हुए , मुझे बताएं कि क्या मैं तेज गति से चल रहा था।

इकाइयों

की मनमानी इकाई में दूरी है d। समय की मनमानी इकाई में है t।

रास्ता

यहाँ एक साधारण सड़क है:

10=====

10साधन 10 dप्रति t। यह सड़क के लिए गति सीमा है। सड़क की 5 =एस है, इसलिए इसका d5. है। इसलिए, अगर मैं 0.5 में उस सड़क को पार करता हूं, तो मैं t10 dप्रति गया t, क्योंकि 5 / 0.5 = 10. उस सड़क की गति सीमा 10 है, इसलिए मैं गति सीमा के भीतर रहा।

लेकिन अगर मैं उस सड़क को 0.25 में पार करता tहूं, तो मैं 20 dप्रति गया t, क्योंकि 5 / 0.25 = 20. उस सड़क की गति सीमा 10 है, इसलिए मैं गति सीमा से 10 अधिक हो गया।

उदाहरण और गणना

ध्यान दें कि इनपुट 1 वह समय है जो मैंने सड़क यात्रा के लिए लिया था, और इनपुट 2 सड़क ही है।

यहाँ एक जटिल सड़क है:

Input 1: 1.5
Input 2: 5=====10=====

सबसे तेज़ (कानूनी रूप से) मैं पहली सड़क पर जा सकता था (पहले 5 =एस) 5 dप्रति t। चूंकि 5 (दूरी) को 5 से विभाजित किया गया है (गति सीमा) 1 है, सबसे तेज मैं उस सड़क पर जा सकता था 1 t।

अगली सड़क पर, गति सीमा 10 है और दूरी भी 5 है, सबसे तेज मैं पार कर सकता है जो 0.5 (5/10) है। 1.5 में न्यूनतम समय परिणाम कुल मिलाकर, जिसका अर्थ है कि मैं बिल्कुल गति सीमा पर चला गया ।

नोट: मुझे पता है, मैं एक सड़क पर वास्तव में तेजी से जा रहा हूं और वास्तव में दूसरे पर धीमा और अभी भी 1.5 में पार कर सकता हूं, लेकिन यहां सबसे अच्छा मान लें।

एक अंतिम उदाहरण:

Input 1: 3.2
Input 2: 3.0==========20===

पहली सड़क 10 लंबी है और 3 की गति सीमा है, इसलिए न्यूनतम समय 3.33333 है ... (10 / 3.)

दूसरी सड़क 3 लंबी है और इसकी गति सीमा 20 है, इसलिए न्यूनतम समय 0.15 (3/20) है।

3.483333333 में परिणाम कुल मिलाकर ... मैंने इसे 3.2 में पार कर लिया है, इसलिए मुझे कहीं तेज होना था।

यदि मुझे निस्संदेह गति मिल रही है, तो आपको एक अलग मूल्य का उत्पादन करना होगा और अगर मैं नहीं कर सकता तो एक अलग मूल्य।
आपके प्रोग्राम या फ़ंक्शन को एक अनुगामी न्यूलाइन होने के लिए इनपुट या आउटपुट की आवश्यकता हो सकती है, लेकिन कृपया इसे अपने सबमिशन में कहें।
आपका पहला इनपुट मेरी गति होगी। यह एक सकारात्मक फ्लोट या पूर्णांक या स्ट्रिंग होगा।
आपका दूसरा इनपुट सड़क होगा। यह हमेशा रेगेक्स से मेल खाएगा ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$। यदि आप रुचि रखते हैं तो आप यहां संभावित इनपुट का परीक्षण कर सकते हैं।
आप एक फ़ंक्शन या प्रोग्राम के 2 मापदंडों में इनपुट ले सकते हैं, 2 अलग-अलग फ़ाइलों में, STDIN से दो बार, या एक अलग-अलग स्ट्रिंग से STDIN, एक फ़ंक्शन, एक फ़ाइल या एक कमांड-लाइन पैरामीटर।
यदि आप चाहें, तो आप इनपुट के क्रम को बदल सकते हैं।
कोई सवाल? नीचे टिप्पणी और खुश कोड-गोल्फ आईएनजी में पूछें !

code-golf ascii-art

— programmer5000
स्रोत

मुझे लगता है कि यह प्रश्न इनपुट के कुछ उदाहरणों से लाभ होगा → आउटपुट उदाहरण।

— L3viathan

3

ऐसा लगता है कि सड़क की गति सीमा में मौजूद दशमलव बिंदुओं को कोई भी सही ढंग से नहीं संभाल रहा है।

— जोनाथन एलन

1

स्पीडोमीटर देखने की कोशिश करो?

— क्रिस्टोफर

@ programmer5000 इसके बजाय, इस रेगेक्स का उपयोग करने के लिए स्वतंत्र महसूस करें ^(([1-9]+[0-9]*|(?!0\.0+\b)[0-9]+\.[0-9]+)=+)+\n?$। (यह एक खोज के साथ क्लीनर होता, लेकिन तब इसे .Net इंजन की आवश्यकता होती है)

— दादा

6

05AB1E , 24 22 बाइट्स

रिटर्न 1 जब निस्संदेह तेजी और 0 अन्यथा।

सहेजे गए 2 बाइट्स कारुसोकोम्प्यूटिंग के लिए धन्यवाद ।

'=¡õK¹S'=Q.¡O0K/O-§'-å

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

-§'-åएक साधारण तुलना से अधिक नहीं होना चाहिए, लेकिन किसी कारण से और न ›ही ‹गणना मूल्य और दूसरे इनपुट के बीच काम करना प्रतीत होता है।

व्याख्या

3.0==========20===, 3.2उदाहरण के रूप में उपयोग करना

'=¡                        # split first input on "="
   õK                      # remove empty strings
                           # STACK: ['3.0', '20']
     ¹S                    # split first input into a list of chars
       '=Q                 # compare each to "="
          .¡O              # split into chunks of consecutive equal elements and sum
                           # STACK: ['3.0', '20'], [0, 10, 0, 3]
             0K            # remove zeroes
                           # STACK: ['3.0', '20'], [10, 3]
               /           # element-wise division
                           # STACK: [3.3333333333333335, 0.15]
                O          # sum
                           # STACK: 3.4833333333333334
                 -         # subtract from second input
                           # STACK: -0.2833333333333332
                  §        # implicitly convert to string
                   '-å     # check if negative
                           # OUTPUT: 1

— Emigna
स्रोत

'=¡õK¹S'=QJ0¡õK€g/O-0.S23 बाइट्स के लिए

— ovs

1

@ नोव्स: तो .Sकाम करता है, ठीक है। हालांकि यह 2 अद्वितीय मानों को वापस नहीं करता है, क्योंकि यह 0 होगा जब आपने बिल्कुल गति सीमा पूरी की होगी।

— एमिग्ना

1

@ इग्नहा गह ... मैं गलत पोस्ट करता रहता हूं; a > bऑपरेटर एक नाव और एक पूर्णांक के बीच तुलना से पहले पूर्णांक तक कास्टिंग है। यह वास्तव में बहुत अजीब है ... मैं इसे 22 बाइट्स तक ले गया, हालांकि '=¡€Þ¹S'=Q.¡O0K/O-§'-å:।

— मैजिक ऑक्टोपस Urn

@carusocomputing: अच्छा! सम्मिश्रण के साथ एक अच्छा विचार था।

— एमिग्ना

@carusocomputing: अंतिम संस्करण जिसे हटाने से पहले आपने you = = vy। O2ôvy g>s/} O-§'-å को 2 वापसी मूल्यों के साथ छोटा किया जा सकता था । शायद वहाँ अभी भी कुछ सुधार किया जाना है? हालांकि मैं नहीं देखता। कि आखिरी तुलना वास्तव में हमें परेशान करती है।

— एमिगा

24

पायथन 2 , 71 बाइट्स

m,s=input()
for c in s.split('=')[:-1]:s=float(c or s);m-=1/s
print m<0

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

पायथन के गतिशील प्रकार प्रणाली में कुछ दुरुपयोग हो सकते हैं।

इनपुट स्ट्रिंग को विभाजित करना खाली-स्ट्रिंग सूची तत्वों में समान संकेतों को s.split('=')बदल देता है (अंत में छोड़कर, जहां किसी को काट दिया जाना चाहिए)। उदाहरण के लिए,kk-1

"3.0===20====".split('=')[:-1] == ['3.0', '', '', '20', '', '', '']

कोड इन तत्वों पर पुनरावृत्ति करता है, वर्तमान गति को अद्यतन करता है sजब भी यह एक संख्या को देखता है। अद्यतन के रूप में किया जाता है s=float(c or s), जहां अगर cएक गैर-रिक्त स्ट्रिंग है, तो हम प्राप्त करते हैं float(c), और अन्यथा इसका c or sमूल्यांकन करते हैं s, जहां float(s)बस रखता है s। ध्यान दें कि cएक स्ट्रिंग है और sएक संख्या है, लेकिन पायथन को लगातार इनपुट प्रकारों की आवश्यकता नहीं है, और floatया तो स्वीकार करता है।

यह भी ध्यान दें कि sगति को संग्रहीत करने वाला चर इनपुट स्ट्रिंग लेने के समान है। स्ट्रिंग का मूल्यांकन तब किया जाता है जब लूप शुरू होता है, और इसे लूप के भीतर बदलने से जो बदल जाता है उसे बदल नहीं पाता है। तो, एक ही वैरिएबल को एक इनिशियलाइज़ेशन पर सहेजने के लिए पुन: उपयोग किया जा सकता है। पहले लूप में हमेशा cएक संख्या होती है, इसलिए एक स्ट्रिंग के रूप में प्रारंभिक भूमिका के s=float(c or s)बारे में परवाह नहीं है s।

प्रत्येक पुनरावृत्ति भत्ते से वर्तमान गति को घटाता है, जो गति सीमा के रूप में शुरू होता है। यदि यह नीचे गिरता है, तो अंत में गति सीमा का उल्लंघन किया गया है 0।

— XNOR
स्रोत

4

मुझे यह बताना चाहिए कि यह पायथन के डायनामिक टाइपिंग (संकलन समय के बजाय रनटाइम पर टाइप जाँच करना) की एक संपत्ति है, कमजोर टाइपिंग नहीं। पायथन के प्रकार वास्तव में बहुत मजबूत हैं (यह स्पष्ट निर्देश के बिना प्रकारों के बीच मूल्यों को परिवर्तित करना आमतौर पर संभव नहीं है )।

— मुजेर

@ मेरी गलती, इसे ठीक कर दिया।

— xnor

17

पायथन 3 , 79 बाइट्स

import re;g=re.sub
lambda m,s:eval(g('=','-~',g('([^=]+)',r'0+1/\1*',s))+'0')>m

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

उदाहरण के लिए, इनपुट 3.0==========20===स्ट्रिंग में बदल जाता है

0+1/3.0*-~-~-~-~-~-~-~-~-~-~0+1/20*-~-~-~0

और मूल्यांकन किया, और परिणाम इनपुट गति की तुलना में है। -~द्वारा प्रत्येक वेतन वृद्धि 1। मैं regexes के लिए नया हूं, इसलिए शायद एक बेहतर तरीका है, जैसे एक ही बार में दोनों प्रतिस्थापन। जोनाथन एलन के लिए धन्यवाद कि कैसे सभी लेकिन =चरित्र पर मैच करना है।

— XNOR
स्रोत

यह अभी भी फ्लोट्स को संभालने में सक्षम नहीं लगता है।

— L3viathan

@ L3viathan क्या आप एक उदाहरण दे सकते हैं कि यह कहाँ गलत है?

— 22

उदाहरण के लिए जब सड़क है "0.5=20===", तो आउटपुट Noneसमय इनपुट की परवाह किए बिना होगा ।

— L3viathan 22

आह, शून्य से भाग दें ...

— जोनाथन एलन

मुझे लगता है कि ([\d|.]+)इसे ठीक कर सकते हैं।

— जोनाथन एलन

6

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

a=>b=>eval(b.replace(/([^=]+)(=+)/g,(_,c,d)=>'+'+d.length/c))>a

प्रयोग

इस फ़ंक्शन को एक चर में असाइन करें और इसे करी सिंटैक्स का उपयोग करके कॉल करें। पहला तर्क समय है, दूसरा सड़क है।

व्याख्या

सभी वर्णों के लगातार रन से मेल खाता है जो समान संकेतों के चलने के बाद समान संकेत नहीं हैं। प्रत्येक मैच को आंतरिक फ़ंक्शन के परिणाम से बदल दिया जाता है, जो दो तर्कों का उपयोग करता है: समान संकेतों की दौड़ (चर में d) और संख्या (चर c)। फ़ंक्शन, सड़क की लंबाई को संख्या से विभाजित करता है, जो कि a + से पूर्ववर्ती है।

परिणामस्वरूप स्ट्रिंग का मूल्यांकन किया जाता है, और पहले इनपुट के खिलाफ तुलना की जाती है।

ढेर स्निपेट

let f=
a=>b=>eval(b.replace(/([^=]+)(=+)/g,(_,c,d)=>'+'+d.length/c))>a

<input id="time" placeholder="time" type="number">
<input id="road" placeholder="road">
<button onclick="output.innerHTML=f(time.value)(road.value)">Process</button>
<div id="output"></div>

स्निपेट का विस्तार करें

— ल्यूक
स्रोत

6

जीएनयू सी, 128 बाइट्स

#import<stdlib.h>
f(float t,char*r){float l,s=0;for(;*r;){for(l=atof(r);*(++r)-61;);for(;*r++==61;)s+=1/l;--r;}return t<s-.001;}

गैर-पूर्णांक गति सीमा भी संभालता है। #import<stdlib.h>संकलक के लिए आवश्यक है कि ग्रहण करने के लिए नहीं atof()रिटर्न एक int।

t<s-.001काम करने के लिए सटीक गति सीमा परीक्षण के मामले को बनाने की आवश्यकता है, अन्यथा गोलाई त्रुटियों के कारण आपको लगता है कि आप गति कर रहे थे। बेशक, अब अगर समय के 1.4999बजाय 1.5, यह उस तेजी पर विचार नहीं करता है। मुझे लगता है कि यह ठीक है।

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

— Steadybox
स्रोत

5

पर्ल 5 , 43 बाइट्स

कोड + -pध्वज के 42 बाइट्स ।

s%[^=]+(=+)%$t+=(length$1)/$&%ge;$_=$t<=<>

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

अंकों के प्रत्येक समूह के लिए कुछ समान संकेतों ( [^=]+(=+)) के बाद, हम गणना करते हैं कि इसे पार करने के लिए कितना समय की आवश्यकता है (गति द्वारा विभाजित बराबर की संख्या:) (length$1)/$&और अंदर उन समय को योग करें $t। अंत में, हमें बस यह जांचने की आवश्यकता है कि $tआपने इसे पार करने के लिए जो समय लिया है उससे कम है ( $_=$t < <>)। परिणाम 1(सच्चा) होगा या कुछ नहीं (झूठा) होगा।

— बापू
स्रोत

दशमलव संख्या को संभालना प्रतीत नहीं होता है।

— L3viathan

@ L3viathan सही, इसे इंगित करने के लिए धन्यवाद। (दशमलव संख्या के साथ कोई परीक्षण मामला नहीं था और मैंने चश्मा बहुत तेजी से पढ़ा)

— दादा

4

गणितज्ञ, 98 बाइट्स

Tr[#2~StringSplit~"="//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}]-"
"<=#&

दो तर्कों को लेने वाला शुद्ध कार्य, एक संख्या (जो पूर्णांक, अंश, दशमलव, सम πया वैज्ञानिक अंक में एक संख्या हो सकती है) और एक नई पंक्ति-समाप्त स्ट्रिंग, और वापस लौटना Trueया False। उदाहरण के माध्यम से स्पष्टीकरण, आदानों का उपयोग कर 3.2और "3==========20===\n":

#2~StringSplit~"="पैदा करता है {"3","","","","","","","","","","20","","","\n"}। ध्यान दें कि प्रत्येक रन में ""निरंतर =s की संख्या की तुलना में निरंतर s की संख्या कम है ।

//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}रिप्लेसमेंट रिप्लेसमेंट नियम है। पहले यह सेट zखाली अनुक्रम करने के लिए, aकरने के लिए "3", bकरने के लिए "","","","","","","","",""(सबसे लंबे समय तक रन ""रों यह मिल सकता है), और cकरने के लिए "20","","","\n"; आदेश का (Length@{b}+1)/ToExpression@aमूल्यांकन करता है (9+1)/3, और इसलिए प्रतिस्थापन का परिणाम सूची है {10/3, "20","","","\n"}।

प्रतिस्थापन नियम सेट अगला zकरने के लिए 10/3, aकरने के लिए "20", bकरने के लिए "","", और cकरने के लिए "\n"। अब (Length@{b}+1)/ToExpression@aमूल्यांकन करता है (2+1)/20, और इसलिए प्रतिस्थापन का परिणाम है {10/3, 3/20, "\n"}। प्रतिस्थापन नियम दूसरा मैच नहीं ढूंढ सकता है, इसलिए यह रुक जाता है।

अंत में, Tr[...]-"\n"(यह उद्धरण के बजाय एक वास्तविक न्यूलाइन का उपयोग करने के लिए एक बाइट बचाता है "\n") सूची के तत्वों को जोड़ता है, प्राप्त करता है 10/3 + 3/20 + "\n", और फिर से घटाता है "\n", जो कि गणितज्ञ पूरी तरह से खुश है। अंत में, <=#पहले इनपुट के परिणाम की तुलना ( 3.2इस मामले में), जो पैदावार करता है False।

— ग्रेग मार्टिन
स्रोत

क्या यह फ्लोटिंग पॉइंट स्पीड के साथ काम करता है?

— कैलकुलेटर

1

हां, जो कुछ भी गणितज्ञ एक संख्या के रूप में पहचानता है। इनपुट "1+2====3.456====π=====\n"भी हो सकता है ।

— ग्रेग मार्टिन

4

जेली , 27 बाइट्स

ṣ”=V€ḟ0
Œr”=e$ÐfṪ€ż⁸Ç¤÷/€S>

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

नोट: यह मानता है कि regex प्रश्न में दिए गए इस तरह के एक गति सीमा नहीं किया जा सकता है कि होना चाहिए 0.0, 0.00, आदि - जैसे यह नहीं किया जा सकता 0( पुष्टि की अनैच्छिक संपत्ति के रूप में)।

कैसे?

ṣ”=V€ḟ0 - Link 1, speed limits: road          e.g. "4.0===22=="
ṣ”=     - split by '='                             [['4','.','0'],[],[],['2','2'],[],[]]
   V€   - evaluate €ach as Jelly code              [4.0,0,0,22,0,0]
     ḟ0 - filter discard zero                      [4.0,22]

Œr”=e$ÐfṪ€ż⁸Ç¤÷/€S> - Main link: road, time   e.g. "4.0===22==", 0.84
Œr                  - run-length encode            [['4',1],['.',1],['0',1],['=',3],['2',2],['=',2]]
      Ðf            - filter keep:
     $              -     last two links as a monad:
  ”=                -         "="
    e               -         is an element of?    [['=',3],['=',2]]
        Ṫ€          - tail €ach                    [3,2]
             ¤      - nilad followed by link(s) as a nilad:
           ⁸        -     left argument (road)
            Ç       -     last link (1) as a monad [4.0,22]
          ż         - zip                          [[3,4.0],[2,22]]
              ÷/€   - reduce €ach by division      [0.75, 0.09090909090909091]
                 S  - sum                          0.8409090909090909
                  > - greater than time?           1 (would be 0 if maybe not speeding)

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

हां, मैंने स्पष्ट 0.0रूप 0से उन मूल्यों के बारे में कहा है जो गति सीमाओं को बाहर निकालने के लिए कोड में मूल्यांकन करने वाले मानों को फ़िल्टर करते हैं।

— जोनाथन एलन

3

पायथन 3, 90 बाइट्स

import re
lambda t,r:sum(x.count("=")/eval(x.strip("="))for x in re.findall("\d+\D+",r))>t

आउटपुट Trueअगर आप तेज कर रहे हैं, Falseअगर आप नहीं हो सकते हैं। न्यूलाइन की अनुगामी की आवश्यकता नहीं है (लेकिन साथ काम करेंगे)।

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

— L3viathan
स्रोत

3

MATL , 31 30 बाइट्स

t61=TwFhhdfd1wY{1L&)o!oswcU!/s<

इनपुट्स हैं: एक स्ट्रिंग (गति सीमा और सड़कें), फिर एक संख्या (प्रयुक्त गति)। आउटपुट 1अगर निस्संदेह गति है, 0यदि नहीं।

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

उदाहरण सहित व्याख्या

आदानों पर विचार करें '3.0==========20==='और 3.2।

1       % Push 1
        % STACK: 1
y       % Implicitly input string. Duplicate from below
        % STACK: '3.0==========20===', 1, '3.0==========20==='
61=     % Compare with 61 (ASCII for '=')
        % STACK: '3.0==========20===', 1, [0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1]
TwFhh   % Prepend true (1) and append false (0)
        % STACK: '3.0==========20===', 1, [1 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 0]
d       % Consecutive differences
        % STACK: '3.0==========20===', 1, [-1 0 0 1 0 0 0 0 0 0 0 0 0 -1 0 1 0 0 -1]
f       % Find: indices of nonzeros
        % STACK: '3.0==========20===', 1, [1  4 14 16 19]
d       % Consecutive differences. Gives length of substrings of numbers or roads
        % STACK: '3.0==========20===', 1, [3 10 2 3]
Y{      % Split string according to those lenghts. Gives a cell array of strings
        % STACK: {'3.0', '==========', '20', '==='}
1L&)    % Split into odd- and even-indexed subarrays
        % STACK: {'3.0', '20'}, {'==========', '==='}
o       % Convert to 2D numeric array. Right-pads with zeros
        % STACK: {'3.0', '20'}, [61 61 61 61 61 61 61 61 61 61; 61 61 61 0 0 0 0 0 0 0]
!gs     % Number of nonzeros in each row
        % STACK: {'3.0', '20'}, [10 3]
w       % Swap
        % STACK: [10 3], {'3.0', '20'}
c       % Convert to 2D char array. Right-pads with spaces
        % STACK: [10 3], ['3.0'; '20 ']
U       % Convert each row to a number
        % STACK: [10 3], [3.0; 20]
!       % Transpose
        % STACK: [10 3], [3.0 20]
/       % Divide, element-wise
        % STACK: [3.3333 0.15]
s       % Sum of array
        % STACK: 3.4833
<       % Implicitly input number. Less than? Implicitly display (true: 1; false: 0)
        % STACK: true

— लुइस मेंडो
स्रोत

2

एपीएल, 41 बाइट्स

{⍺<+/{(≢⍵)÷⍎⍺}/¨Y⊂⍨2|⍳⍴Y←⍵⊂⍨X≠¯1⌽X←⍵='='}

यह सड़क को अपने सही तर्क के रूप में एक स्ट्रिंग के रूप में लेता है, और समय को इसके बाएं तर्क के रूप में लिया जाता है, और 1यदि आप तेजी से आगे बढ़ रहे हैं और 0यदि ऐसा है तो वापस लौटते हैं :

      3.2{⍺<+/{(≢⍵)÷⍎⍺}/¨Y⊂⍨2|⍳⍴Y←⍵⊂⍨X≠¯1⌽X←⍵='='}'3.0==========20==='
1

स्पष्टीकरण:

X←⍵='=': सड़क के हिस्से Xमें सभी पदों के एक बिट वेक्टर में स्टोर करें ⍵।
X≠¯1⌽X: Xउस स्थिति में से प्रत्येक की स्थिति उसके सही पड़ोसी (चारों ओर लपेटना) के बराबर नहीं है, जहां पद और सड़कें शुरू होती हैं
Y←⍵⊂⍨: ⍵इन पदों पर विभाजित (वैकल्पिक संख्या और सड़क तार की एक सरणी दे), और इसे स्टोर करें Y।
Y⊂⍨2|⍳⍴Y: Yलगातार जोड़े में विभाजित ।
{(≢⍵)÷⍎⍺}/¨: प्रत्येक जोड़ी के लिए, सड़क के भाग की लंबाई ( ≢⍵) संख्या भाग के मूल्यांकन के परिणाम से विभाजित करें ( ⍎⍺)। यह प्रत्येक खंड के लिए न्यूनतम समय देता है।
+/: सभी खंडों के लिए कुल न्यूनतम समय प्राप्त करने का समय।
⍺<: जांचें कि क्या दिया गया समय न्यूनतम से कम है या नहीं।

— मारीनस
स्रोत

2

टीआई-बेसिक, 168 165 बाइट्स

Prompt Str0,T
Str0+"0→Str0
0→I
1→A
While inString(Str0,"=",A
I+1→I
I→dim(L₁
I→dim(L₂
0→L
inString(Str0,"=",A→B
expr(sub(Str0,A,B–A→L₁(I
While 1=expr("9"+sub(Str0,B,1)+"9
L+1→L
B+1→B
If B>length(Str0
Return
End
B→A
L→L₂(I
End
T≥sum(seq(L₂(X)/L₁(X),X,1,I

इनपुट सड़क के रूप में Str0और समय के रूप में है T। एक उद्धरण के साथ सड़क को पूर्ववर्ती करना सुनिश्चित करें, जैसे Str0=?"14========3===।

आउटपुट 0 है अगर गति, 1 यदि संभवत: गति नहीं है।

Prompt Str0,T                      # 6 bytes
Str0+"0→Str0                       # 9 bytes
0→I                                # 4 bytes
1→A                                # 4 bytes
While inString(Str0,"=",A          # 12 bytes
I+1→I                              # 6 bytes
I→dim(L₁                           # 6 bytes
I→dim(L₂                           # 6 bytes
0→L                                # 4 bytes
inString(Str0,"=",A→B              # 13 bytes
expr(sub(Str0,A,B–A→L₁(I           # 16 bytes
While 1=expr("9"+sub(Str0,B,1)+"9  # 21 bytes
L+1→L                              # 6 bytes
B+1→B                              # 6 bytes
If B>length(Str0                   # 8 bytes
Return                             # 2 bytes
End                                # 2 bytes
B→A                                # 4 bytes
L→L₂(I                             # 7 bytes
End                                # 2 bytes
T≥sum(seq(L₂(X)/L₁(X),X,1,I        # 21 bytes

— pizzapants184
स्रोत

1

बैश, 151 बाइट्स

के रूप में चल रहा है (उदाहरण के लिए) $ bash golf.sh .5 10=====:

shopt -s extglob
r=$2
while [ -n "$r" ];do
f=${r%%+(=)}
s=`dc<<<"9k$s $[${#r}-${#f}] ${f##*=}/+p"`
r=${f%%+([0-9.])}
done
[[ `dc<<<"$1 $s-p"` != -* ]]

व्याख्या

shopt -s extglob
r=$2

बैश के विस्तारित पैटर्न-मिलान वाले ऑपरेटरों को सक्षम करें और सड़क को एक चर में असाइन करें r।

while [ -n "$r" ];do
f=${r%%+(=)}

rखाली होने तक लूप करें । सेट fकरने के लिए rके साथ सभी को समान लक्षण अंत से हटा दिया, का उपयोग कर %% पैरामीटर विस्तार और +()बढ़ाया ग्लोबिंग ऑपरेटर।

s=`dc<<<"9k$s $[${#r}-${#f}] ${f##*=}/+p"`

sप्रत्येक सड़क सेगमेंट के लिए न्यूनतम समय की एक रनिंग राशि को असाइन करें । यह फिर से लिखा जा सकता है (शायद थोड़ा) अधिक आसानी से:

s=$(dc <<< "9k $s $[${#r}-${#f}] ${f##*=} / + p")

मूल रूप से यहाँ क्या चल रहा है, हम अपने dcलिए गणित करने के लिए कमांड प्राप्त करने के लिए यहां एक स्ट्रिंग का उपयोग कर रहे हैं , क्योंकि बैश फ्लोटिंग-पॉइंट अंकगणित स्वयं नहीं कर सकता है। 9kसटीक सेट करता है, ताकि हमारा विभाजन फ्लोटिंग-पॉइंट हो, और pजब हम कर रहे हैं तब परिणाम प्रिंट करता है। यह एक रिवर्स-पॉलिश कैलकुलेटर है, इसलिए जो हम वास्तव में गणना कर रहे हैं , वह हमारे वर्तमान योग से ${f##*=}विभाजित है $[${#r}-${#f}], (या, जब हम पहली बार दौड़ते हैं और sअभी तक सेट नहीं हुए हैं, तो कुछ भी नहीं, जो हमें dc' stderr ' के बारे में चेतावनी संदेश देता है ' स्टैक खाली हो रहा है, लेकिन यह अभी भी सही संख्या प्रिंट करता है क्योंकि हम वैसे भी शून्य में जोड़ रहे हैं)।

वास्तविक मान हम विभाजित कर रहे हैं के लिए के रूप में: ${f##*=}है fसबसे बड़ा पैटर्न मिलान के साथ *=सामने से हटा दिया। चूंकि fहमारी वर्तमान सड़क अंत से हटाए गए सभी समान संकेतों के साथ है, इसका मतलब यह है कि ${f##*=}सड़क के इस विशेष खिंचाव के लिए गति सीमा है। उदाहरण के लिए, यदि हमारी सड़क r'10 ===== 5 === 'है, तो f'10 ===== 5' होगी, और इसलिए ${f##*=}'5' होगा।

$[${#r}-${#f}]सड़क के हमारे खिंचाव के अंत में समान संकेतों की संख्या है। ${#r}की लंबाई है r; के बाद से fबस है rअंत हटाया बिल्कुल बराबर संकेत के साथ, हम सिर्फ इसकी लंबाई के से घटाना कर सकते हैं rइस सड़क अनुभाग की लंबाई प्राप्त करने के लिए।

r=${f%%+([0-9.])}
done

सड़क की गति सीमा के इस भाग को, सड़क के fअन्य सभी हिस्सों को छोड़कर, और rउस पर सेट करें, जिससे कि अगली सड़क के अगले हिस्से को संसाधित किया जा सके।

[[ `dc<<<"$1 $s-p"` != -* ]]

यह देखने के लिए परीक्षण करें कि क्या हमने सड़क यात्रा करने के लिए समय दिया (प्रदान की गई $1) गति सीमा द्वारा अनुमत न्यूनतम से कम है। यह न्यूनतम, sएक फ्लोट हो सकता है, इसलिए हम dcतुलना करने के लिए फिर से मुड़ते हैं । dcएक तुलना ऑपरेटर है, लेकिन वास्तव में इसका उपयोग करने से इसकी तुलना में 9 अधिक बाइट्स समाप्त हो गए हैं, इसलिए इसके बजाय मैं अपनी यात्रा के समय को न्यूनतम से घटाता हूं और यह देखने के लिए जांच करता हूं कि क्या यह जांच से नकारात्मक है यदि यह डैश से शुरू होता है। शायद असभ्य, लेकिन प्यार और कोडगॉल्फ में सभी निष्पक्ष।

चूँकि यह जाँच स्क्रिप्ट की अंतिम कमांड है, इसलिए इसका रिटर्न मान स्क्रिप्ट द्वारा वापस लौटाया जाएगा: 0 यदि संभवत: तेज़ हो, 1 यदि निश्चित रूप से तेज़ हो तो:

$ bash golf.sh .5 10===== 2>/dev/null && echo maybe || echo definitely
maybe
$ bash golf.sh .4 10===== 2>/dev/null && echo maybe || echo definitely
definitely

— charliegreen
स्रोत

1

पायथन 3.6, 111 बाइट्स

मेरा पहला कोड गोल्फ!

import re
def f(a,b):
 t=0
 for c in re.split('(=+)',b)[:-1]:
  try:s=float(c)
  except:t+=len(c)/s
 return a<t

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

re.split('(=+)',b)[:-1] के टुकड़े करके सड़क को विभाजित करता है =।

यह तब परिणाम पर निर्भर करता है, try:s=float(c)वर्तमान गति सीमा निर्धारित करने के लिए यदि वर्तमान आइटम एक संख्या है या except:t+=len(c)/sसड़क के इस भाग को संचयी कुल में पार करने के लिए समय जोड़ने के लिए उपयोग करता है।

अंत में यह सबसे तेजी से संभव समय के लिए लिया गया समय देता है।

— Notts90
स्रोत

अपने पहले कोड गोल्फ के लिए बधाई! अच्छी तरह से किया!

— प्रोग्रामर

1

PHP5 207 202 बाइट्स

एक कोड गोल्फ उत्तर में पहला प्रयास, कृपया मुझ पर आसान हो। मुझे यकीन है कि आप में से एक जीनियस इसे महत्वपूर्ण रूप से छोटा करने में सक्षम होगा, किसी भी गोल्फिंग टिप्स का स्वागत है।

function s($c,$d){foreach(array_filter(split("[{$d}/=]",$c)) as $e){$f[]=$e;};return $f;}function x($a,$b){$c=s($b,"^");$d=s($b,"");for($i=0;$i<sizeof($c);$i++){$z+=strlen($c[$i])/$d[$i];}return $a<$b;}

के साथ आह्वान किया

x("1.5","3.0==========20===")

सच है अगर आप गति सीमा के तहत किया गया है, तो झूठे अन्यथा

— डैरेन एच
स्रोत

1

अच्छा प्रथम प्रस्तुत!

— प्रोग्रामर

5 चर को काटकर यह महसूस करें कि लूप में आने से पहले मुझे $ z घोषित करने की आवश्यकता नहीं थी

— डैरेन एच।

1

दिल्लोग एपीएल, 27 बाइट्स

<∘(+/(⍎'='⎕r' ')÷⍨'=+'⎕s 1)

'=+'⎕s 1एक ऐसा फंक्शन है जो '='एक रेगेक्स के साथ स्ट्रेच की पहचान करता है और उनकी लंबाई के वेक्टर को लौटाता है ( ⎕s'सही ऑपरेंड 0 का अर्थ ऑफसेट होता है; 1 - लंबाई; 2 - रेक्सक्स के सूचक जो मेल खाते हैं)

'='⎕r' 'जगह के '='साथ एस

⍎'='⎕r' ' इसे निष्पादित करता है - गति का एक वेक्टर देता है

÷⍨ बीच में दो वैक्टर (⍨ तर्कों को स्वैप करता है, इसलिए यह गति से विभाजित दूरी है)

+/ राशि है

अब तक सब कुछ एक 4-ट्रेन है - एक स्पष्ट तर्क के बिना एक फ़ंक्शन

<∘उस फ़ंक्शन के सामने "कम से कम" बनाता है; इसलिए, फ़ंक्शन केवल सही तर्क पर कार्य करेगा और इसके परिणाम की तुलना बाएं तर्क के खिलाफ की जाएगी

— NGN
स्रोत

1

एफ # (165 बाइट्स)

let rec c t p l=
 match l with
 |[]->t<0.0
 |x::xs->
  match x with
  |""->c(t-p)p xs
  |_->c(t-p)(1.0/float x)xs
let s t (r:string)=r.Split '='|>Seq.toList|>c t 0.0

मैं अभी भी F # में नया हूं, इसलिए अगर मैंने कुछ भी अजीब या बेवकूफ किया, तो मुझे बताएं।

— रिक
स्रोत

1

सी # विधि ( 137 122 बाइट्स)

using System.Linq122 में शामिल 19 बाइट्स जोड़ने की आवश्यकता है :

bool C(float t,string r,float p=0)=>r.Split('=').Aggregate(t,(f,s)=>f-(s==""?p:p=1/float.Parse(s)))<-p;

विस्तारित संस्करण:

bool Check(float time, string road, float pace=0) => 
    road.Split('=')
        .Aggregate(time, (f, s) => f - (
            s == "" 
            ? pace 
            : pace = 1 / float.Parse(s))) 
        < -pace;

roadस्ट्रिंग पर विभाजित है =चरित्र। इसके आधार पर कि क्या कोई स्ट्रिंग परिणामी सरणी है खाली है, कुल फ़ंक्शन paceसेगमेंट के लिए चर सेट करता है (एक यात्रा करने के लिए समय लगता है =) और आपूर्ति की गई समय से घटाता है। यह (अंतिम रोड सेगमेंट के लिए) एक बहुत अधिक विकल्प करेगा, इसलिए तुलना करने के बजाय 0, हम तुलना करते हैं-pace

— रिक
स्रोत

1

आर , 100 बाइट्स

function(S,R){s=strsplit(R,"=")[[1]]
s[s==""]=0
S<sum((1+(a=rle(as.double(s)))$l[!a$v])/a$v[a$v>0])}

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

संभवतः अनिर्दिष्ट लोगों के TRUEलिए स्पष्ट रूप से तेजी से मूल्यों के लिए रिटर्न FALSE।

— ग्यूसेप
स्रोत

0

पॉवरशेल , 71 बाइट्स

param($t,$r)$t-lt($r-replace'(.+?)(=+)','+($2)/$1'-replace'=','+1'|iex)

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

टेस्ट स्क्रिप्ट:

$f = {

param($t,$r)$t-lt($r-replace'(.+?)(=+)','+($2)/$1'-replace'=','+1'|iex)

}

@(
    ,(1.5, "5=====10=====", $false)
    ,(3.2, "3.0==========20===", $true)
) | % {
    $time,$road,$expected = $_
    $result = &$f $time $road
    "$($result-eq$expected): $result"
}

आउटपुट:

True: False
True: True

स्पष्टीकरण:

स्क्रिप्ट सड़क के तत्वों को प्राप्त करती है 5=====10=====, तत्वों को स्वैप करती है, कोष्ठक और ऑपरेटरों को जोड़ती है+(=====)/5+(=====)/10
फिर स्क्रिप्ट प्रत्येक के =साथ प्रतिस्थापित करती है +1:+(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
अंत में, स्क्रिप्ट स्ट्रिंग का पॉवरशेल अभिव्यक्ति के रूप में मूल्यांकन करती है और पहले तर्क के साथ तुलना करती है।

— Mazzy
स्रोत

क्या मैं गति सीमा से अधिक हूं?

इकाइयों

रास्ता

उदाहरण और गणना

टिप्पणियाँ:

05AB1E , 24 22 बाइट्स

पायथन 2 , 71 बाइट्स

पायथन 3 , 79 बाइट्स

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

प्रयोग

व्याख्या

ढेर स्निपेट

जीएनयू सी, 128 बाइट्स

पर्ल 5 , 43 बाइट्स

गणितज्ञ, 98 बाइट्स

जेली , 27 बाइट्स

कैसे?

पायथन 3, 90 बाइट्स

MATL , 31 30 बाइट्स

उदाहरण सहित व्याख्या

एपीएल, 41 बाइट्स

टीआई-बेसिक, 168 165 बाइट्स

बैश, 151 बाइट्स

व्याख्या

पायथन 3.6, 111 बाइट्स

PHP5 207 202 बाइट्स

दिल्लोग एपीएल, 27 बाइट्स

एफ # (165 बाइट्स)

सी # विधि ( 137 122 बाइट्स)

आर , 100 बाइट्स

पॉवरशेल , 71 बाइट्स