ฉันเกินขีด จำกัด ความเร็วหรือไม่

33

ให้ถนนศิลปะและเวลาที่ฉันต้องข้ามมันบอกฉันว่าฉันกำลังเร่ง

หน่วย

dระยะทางที่อยู่ในหน่วยโดยพลการของ tเวลาที่อยู่ในหน่วยโดยพลการของ

ถนน

นี่คือถนนที่เรียบง่าย:

10=====

10หมายถึง 10 ต่อd tนั่นคือขีด จำกัด ความเร็วสำหรับถนน ถนนมี 5 =วิดังนั้นมันdคือ 5 ดังนั้นหากฉันข้ามถนนนั้นใน 0.5 tฉันไป 10 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 =s) 5 ต่อd tตั้งแต่ 5 (ระยะทาง) หารด้วย 5 ( จำกัด ความเร็ว) คือ 1, ที่เร็วที่สุดที่ฉันจะได้ไปอยู่บนท้องถนนที่เป็น t1

บนถนนสายถัดไปขีด จำกัด ความเร็วคือ 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?$regex คุณอาจทดสอบอินพุตที่อาจเป็นไปได้ที่นี่หากคุณสนใจ
  • คุณอาจรับพารามิเตอร์ 2 อย่างของฟังก์ชันหรือโปรแกรมใน 2 ไฟล์แยกจาก STDIN สองครั้งหรือจากสตริงที่คั่นด้วยช่องว่างที่ส่งผ่านไปยัง STDIN, ฟังก์ชั่น, ไฟล์หรือพารามิเตอร์บรรทัดคำสั่ง
  • หากคุณต้องการคุณสามารถเปลี่ยนลำดับของอินพุต
  • มีคำถามอะไรไหม? ถามด้านล่างในความคิดเห็นและความสุขรหัสกอล์ฟ !
code-golf  ascii-art 
— programmer5000
แหล่งที่มา
ฉันคิดว่าคำถามนี้จะได้รับประโยชน์จากตัวอย่างอินพุต→ input สองตัวอย่าง
— L3viathan
3
ดูเหมือนว่าไม่มีใครสามารถจัดการจุดทศนิยมได้อย่างถูกต้องในขีด จำกัด ความเร็วของถนน
— Jonathan Allan
1
ลองดูมาตรวัดความเร็ว?
— Christopher
@ programmer5000 แล้วรู้สึกอิสระที่จะใช้ regex ^(([1-9]+[0-9]*|(?!0\.0+\b)[0-9]+\.[0-9]+)=+)+\n?$นี้แทน (มันน่าจะสะอาดกว่าเดิมด้วยการมอง แต่หลังจากนั้นมันต้องใช้. net engine)
— Dada

คำตอบ:

6

05AB1E , 24 22 ไบต์

ผลตอบแทนที่1เมื่อเร่งความเร็วอย่างไม่ต้องสงสัยและ0 เป็นอย่างอื่น

ที่บันทึกไว้ 2 ไบต์ขอบคุณที่carusocomputing

'=¡õ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.Sสำหรับ 23 ไบต์
— ovs
1
@ovs: ได้.Sผลตกลง แต่นั่นจะไม่ส่งคืนค่าที่ไม่ซ้ำกัน 2 ค่าเนื่องจากจะส่งคืนค่า 0 เมื่อคุณดำเนินการ จำกัด ความเร็ว
— Emigna
1
@Emigna gahh ... ฉันโพสต์ผิดไปเรื่อย ๆ a > bผู้ประกอบการหล่อจำนวนเต็มก่อนที่จะเปรียบเทียบระหว่างลอยและ int มันแปลกมากแน่นอน ... ฉันไม่ได้รับมันลงไป 22 '=¡€Þ¹S'=Q.¡O0K/O-§'-åไบต์ว่า:
— Magic Octopus Urn
@carusocomputing: ดี! การทำให้อ้วนด้วยการรวมเป็นความคิดที่ดี
— Emigna
@carusocomputing: เวอร์ชันสุดท้ายที่คุณมีก่อนที่จะลบสามารถย่อให้เหลือ¨ '= ¡.¡2ôvy g>s/} O-§'-åที่ 23 โดยมีค่าส่งคืน 2 ค่า อาจจะมีการปรับปรุงให้ดีขึ้นบ้าง? ฉันไม่เห็นว่าจะเกิดอะไรขึ้น การเปรียบเทียบที่ผ่านมาทำให้เรากลัวจริงๆ
— Emigna
24

Python 2 , 71 ไบต์

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

ลองออนไลน์!

ระบบประเภทพลวัตของไพ ธ อนสามารถใช้ในทางที่ผิดได้บ้าง

การแยกสตริงอินพุตs.split('=')เปลี่ยนkสัญญาณเท่ากันให้เป็นk-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เป็นตัวเลข แต่ Python ไม่ต้องการไม่ต้องการประเภทอินพุตที่สอดคล้องกันและfloatยอมรับอย่างใดอย่างหนึ่ง

โปรดทราบว่าตัวแปรที่sจัดเก็บความเร็วนั้นเหมือนกันกับการรับสตริงอินพุต สตริงจะถูกประเมินเมื่อลูปเริ่มต้นและการเปลี่ยนแปลงภายในลูปจะไม่เปลี่ยนสิ่งที่วนซ้ำ ดังนั้นตัวแปรเดียวกันสามารถนำมาใช้ซ้ำเพื่อบันทึกในการเริ่มต้น การวนซ้ำครั้งแรกจะมีcตัวเลขเสมอดังนั้นs=float(c or s)อย่าสนใจsบทบาทเริ่มต้นของสตริง

การวนซ้ำแต่ละครั้งจะลบความเร็วปัจจุบันออกจากค่าเผื่อซึ่งเริ่มต้นเป็นขีด จำกัด ความเร็ว ในตอนท้ายขีด จำกัด 0ความเร็วที่ได้รับการละเมิดถ้าต่ำกว่านี้

— XNOR
แหล่งที่มา
4
ฉันต้องชี้ให้เห็นว่านี่เป็นคุณสมบัติของการพิมพ์แบบไดนามิกของ Python (การแสดงการตรวจสอบประเภทที่รันไทม์มากกว่าการรวบรวมเวลา) ไม่ใช่การพิมพ์ที่อ่อนแอ ประเภทของงูหลามนั้นค่อนข้างแข็งแกร่ง (โดยทั่วไปไม่สามารถแปลงค่าระหว่างประเภทโดยไม่มีคำแนะนำที่ชัดเจน)
— Muzer
@ Muzer ความผิดพลาดของฉันแก้ไขได้
— xnor
17

Python 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 คุณช่วยยกตัวอย่างที่ผิดพลาดได้ไหม?
— xnor
ตัวอย่างเช่นเมื่อถนนอยู่"0.5=20==="ผลลัพธ์จะNoneไม่คำนึงถึงเวลาเข้า
— L3viathan
อ่าหารด้วยศูนย์ ...
— Jonathan Allan
ฉันคิดว่า([\d|.]+)อาจแก้ไขได้
— Jonathan Allan
6

Javascript (ES6), 63 ไบต์

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

การใช้

กำหนดฟังก์ชั่นนี้ให้กับตัวแปรแล้วเรียกมันโดยใช้รูปแบบ currying อาร์กิวเมนต์แรกคือเวลาที่สองคือถนน

คำอธิบาย

จับคู่การเรียกใช้อักขระต่อเนื่องทั้งหมดที่ไม่ใช่เครื่องหมายเท่ากับแล้วตามด้วยเครื่องหมายเท่ากับ แต่ละการแข่งขันจะถูกแทนที่ด้วยผลลัพธ์ของฟังก์ชันภายในซึ่งใช้สองอาร์กิวเมนต์: การรันเครื่องหมายเท่ากับ (ในตัวแปรd) และตัวเลข (ตัวแปรc) ฟังก์ชันจะคืนค่าความยาวของถนนที่เบี่ยงเบนตามจำนวนโดยมีเครื่องหมาย +

สตริงผลลัพธ์จะถูกประเมินและเปรียบเทียบกับอินพุตแรก

กองย่อย

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

GNU C, 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

Perl 5 , 43 ไบต์

42 ไบต์ของรหัสเมือง + -pธง

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

ลองออนไลน์!

สำหรับแต่ละกลุ่มหลักตามด้วยเครื่องหมายเท่ากับ (บาง[^=]+(=+)) เราคำนวณเท่าใดเวลาเป็นสิ่งจำเป็นที่จะข้ามมัน (จำนวนเท่ากับหารด้วยความเร็ว: (length$1)/$&) $tและสรุปผลภายในเวลาเหล่านั้น ในตอนท้ายเราแค่ต้องตรวจสอบว่า$tน้อยกว่าเวลาที่คุณใช้ในการข้ามมัน ( $_=$t < <>) ผลลัพธ์จะเป็น1(จริง) หรือไม่มีอะไร (เท็จ)

— Dada
แหล่งที่มา
ดูเหมือนจะไม่จัดการกับตัวเลขทศนิยม
— L3viathan
@ L3viathan ถูกต้องขอบคุณที่ชี้ให้เห็น (ไม่มีกรณีทดสอบใด ๆ ที่มีตัวเลขทศนิยมและฉันอ่านรายละเอียดเร็วไปหน่อย)
— Dada
4

Mathematica ขนาด 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ไป"","","","","","","","",""(ระยะที่ยาวที่สุดของ""s มันสามารถหา) และ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"ซึ่ง Mathematica มีความสุขอย่างสมบูรณ์ที่จะทำ สุดท้าย<=#เปรียบเทียบผลกับอินพุตแรก ( 3.2ในกรณีนี้) Falseซึ่งอัตราผลตอบแทน

— Greg Martin
แหล่งที่มา
มันใช้งานได้กับความเร็วจุดลอยตัวหรือไม่?
— CalculatorFeline
1
ใช่สิ่งที่ Mathematica จำได้ว่าเป็นตัวเลข การป้อนข้อมูลที่อาจเป็น"1+2====3.456====π=====\n"แม้กระทั่ง
— Greg Martin
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)
— Jonathan Allan
แหล่งที่มา
ใช่ฉันระบุไว้อย่างชัดเจน0.0ตั้งแต่ฉันกรองค่าที่ประเมินเช่นเดียวกับ0ในรหัสเพื่อดึงขีด จำกัด ความเร็ว
— Jonathan Allan
3

Python 3, 90 ไบต์

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

เอาท์พุท Trueหากคุณกำลังเร่งFalseถ้าคุณอาจจะไม่ ไม่ต้องการ (แต่จะทำงานร่วมกับ) ขึ้นบรรทัดใหม่

แม้ว่ามันจะไม่ได้ดูเหมือนว่ามันจะจัดการลอยอย่างถูกต้องทั้งในเวลาเข้าและการ จำกัด ความเร็วเพราะ regex ใช้เพียงเพื่อแยกส่วนถนน

— 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

APL, 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เป็นคู่ติดต่อกัน
  • {(≢⍵)÷⍎⍺}/¨: สำหรับแต่ละคู่ให้แบ่งความยาวของส่วนถนน ( ≢⍵) โดยผลการประเมินหมายเลขชิ้นส่วน ( ⍎⍺) สิ่งนี้ให้เวลาขั้นต่ำสำหรับแต่ละเซกเมนต์
  • +/: รวมเวลาสำหรับกลุ่มทั้งหมดเพื่อให้ได้เวลารวมขั้นต่ำ
  • ⍺<: ตรวจสอบว่าเวลาที่กำหนดน้อยกว่าค่าต่ำสุดหรือไม่
— marinus
แหล่งที่มา
2

TI-Basic, 168 165 ไบต์

Prompt Str0,T
Str0+"0→Str0
0→I
1→A
While inString(Str0,"=",A
I+1→I
I→dim(L1
I→dim(L2
0→L
inString(Str0,"=",A→B
expr(sub(Str0,A,B–A→L1(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→L2(I
End
T≥sum(seq(L2(X)/L1(X),X,1,I

ขาเข้าถนนเป็นที่และเวลาเป็นStr0 ให้แน่ใจว่าจะนำหน้าถนนที่มีการอ้างเช่นTStr0=?"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(L1                           # 6 bytes
I→dim(L2                           # 6 bytes
0→L                                # 4 bytes
inString(Str0,"=",A→B              # 13 bytes
expr(sub(Str0,A,B–A→L1(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→L2(I                             # 7 bytes
End                                # 2 bytes
T≥sum(seq(L2(X)/L1(X),X,1,I        # 21 bytes
— pizzapants184
แหล่งที่มา
1

Bash, 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ยังไม่ได้ตั้งค่าไม่มีสิ่งใดที่ทำให้เราได้รับข้อความเตือนเกี่ยวกับ stderr เกี่ยวกับdc ' สแต็กว่างเปล่า แต่ก็ยังพิมพ์หมายเลขที่ถูกต้องเพราะเราจะเพิ่มให้เป็นศูนย์ต่อไป)

สำหรับค่าจริงที่เรากำลังหาร: ${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 ไบต์มากกว่านี้ดังนั้นฉันจึงลบเวลาการเดินทางของเราจากขั้นต่ำและตรวจสอบเพื่อดูว่ามันเป็นค่าลบโดยการตรวจสอบว่ามันเริ่มต้นด้วยเส้นประหรือไม่ บางทีไม่สุภาพ แต่ความยุติธรรมอยู่ในความรักและ codegolf

เนื่องจากการตรวจสอบนี้เป็นคำสั่งสุดท้ายในสคริปต์ค่าส่งคืนจะถูกส่งคืนโดยสคริปต์เช่นกัน: 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

Python 3.6, 111 bytes

รหัสกอล์ฟครั้งแรกของฉัน!

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
แหล่งที่มา
ขอแสดงความยินดีกับกอล์ฟรหัสแรกของคุณ! ทำได้ดีมาก!
— programmer5000
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===")

ผลตอบแทนจริงถ้าคุณอยู่ภายใต้การ จำกัด ความเร็วเท็จอย่างอื่น

— Darren H
แหล่งที่มา
1
ส่งแรกที่ดี!
— programmer5000
ตัด 5 ตัวอักษรโดยตระหนักว่าฉันไม่จำเป็นต้องประกาศ $ z ก่อนที่จะเข้าถึงมันในลูป
— Darren H
1

Dyalog APL ขนาด 27 ไบต์

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

'=+'⎕s 1เป็นฟังก์ชันที่ระบุการยืดของ'='ด้วย regex และส่งคืนเวกเตอร์ของความยาว ( ⎕sตัวถูกดำเนินการด้านขวา 0 จะหมายถึงออฟเซ็ต; 1 - ความยาว; 2 - ดัชนีของ regexes ที่ตรงกัน)

'='⎕r' 'แทนที่'='s ด้วยช่องว่าง

⍎'='⎕r' ' รันมัน - คืนค่าเวกเตอร์ของความเร็ว

÷⍨ตรงกลางจะหารเวกเตอร์สองตัว ( ⍨สลับค่าอาร์กิวเมนต์ดังนั้นมันคือระยะทางหารด้วยความเร็ว)

+/ คือผลรวม

ทุกอย่างจนถึงขณะนี้คือรถไฟ 4 ขบวน - ฟังก์ชันที่ไม่มีอาร์กิวเมนต์ชัดเจน

<∘ประกอบด้วย "น้อยกว่า" ด้านหน้าของฟังก์ชันนั้น ดังนั้นฟังก์ชั่นจะทำงานเฉพาะกับอาร์กิวเมนต์ที่ถูกต้องและผลลัพธ์ของมันจะถูกเปรียบเทียบกับอาร์กิวเมนต์ซ้าย

— NGN
แหล่งที่มา
1

F # (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 # ดังนั้นถ้าฉันทำอะไรแปลก ๆ หรือโง่ ๆ ให้ฉันรู้

— Rik
แหล่งที่มา
1

วิธี C # ( 137 122 ไบต์)

ต้องมีusing System.Linqการเพิ่ม 19 ไบต์รวมอยู่ใน 122:

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

— Rik
แหล่งที่มา
0

PowerShell , 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

คำอธิบาย:

  1. สคริปต์จะได้รับองค์ประกอบของถนน5=====10=====องค์ประกอบการแลกเปลี่ยนเพิ่มวงเล็บและผู้ประกอบการ+(=====)/5+(=====)/10
  2. จากนั้นสคริปต์จะแทนที่=ด้วย+1:+(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
  3. ในที่สุดสคริปต์ประเมินสตริงเป็นนิพจน์ Powershell และเปรียบเทียบกับอาร์กิวเมนต์แรก
— Mazzy
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.