Đưa ra một con đường nghệ thuật và thời gian để tôi băng qua nó, hãy nói cho tôi biết nếu tôi đang tăng tốc.

Các đơn vị

Khoảng cách là trong đơn vị tùy ý của d. Thời gian là trong đơn vị tùy ý của t.

Con đường

Đây là một con đường đơn giản:

10=====

Có 10nghĩa là 10 dmỗi t. Đó là giới hạn tốc độ cho đường. Đường có 5 =giây, vì vậy dlà 5. Do đó, nếu tôi băng qua đường đó trong 0,5 t, tôi đã đi 10 dmỗi lần t, vì 5 / 0,5 = 10. Giới hạn tốc độ của đường đó là 10, vì vậy tôi ở trong giới hạn tốc độ.

Nhưng nếu tôi băng qua con đường đó trong 0,25 t , tôi đã đi 20 dmỗi lần t, vì 5 / 0,25 = 20. Giới hạn tốc độ của con đường đó là 10, vì vậy tôi đã đi quá 10 giới hạn tốc độ.

Ví dụ và tính toán

Lưu ý rằng đầu vào 1 là thời gian tôi đi để đi trên đường và đầu vào 2 là đường chính nó.

Đây là một con đường phức tạp:

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

Tốc độ nhanh nhất tôi có thể có (về mặt pháp lý) đã đi trên con đường đầu tiên (5 =giây đầu tiên ) là 5 dmỗi lần t. Vì 5 (khoảng cách) chia cho 5 (giới hạn tốc độ) là 1, nên tốc độ tôi có thể đi nhanh nhất trên con đường đó là 1 t.

Trên đường tiếp theo, giới hạn tốc độ là 10 và khoảng cách cũng là 5, tốc độ nhanh nhất tôi có thể vượt qua là 0,5 (5/10). Tổng số lần tối thiểu cho kết quả là 1,5, nghĩa là tôi đã đi chính xác giới hạn tốc độ.

Lưu ý: Tôi biết, tôi có thể đã đi rất nhanh trên một con đường và thực sự chậm trên một con đường khác và vẫn vượt qua 1,5, nhưng giả sử tốt nhất ở đây.

Một ví dụ cuối cùng:

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

Con đường đầu tiên dài 10 và có giới hạn tốc độ là 3, vì vậy thời gian tối thiểu là 3.33333 ... (10/3)

Đường thứ hai dài 3 và có giới hạn tốc độ là 20, vì vậy thời gian tối thiểu là 0,15 (3 / 20.)

Tổng số lần kết quả trong 3,483333333 ... Tôi đã vượt qua nó trong 3,2, vì vậy tôi phải tăng tốc ở đâu đó.

Ghi chú:

• Bạn phải xuất một giá trị riêng biệt nếu tôi chắc chắn đang tăng tốc và một giá trị khác nếu tôi không thể.
• Chương trình hoặc chức năng của bạn có thể yêu cầu đầu vào hoặc đầu ra phải có một dòng mới, nhưng vui lòng nói như vậy trong bài nộp của bạn.
• Đầu vào đầu tiên của bạn sẽ là tốc độ của tôi. Nó sẽ là một số float hoặc số nguyên hoặc chuỗi dương.
• Đầu vào thứ hai của bạn sẽ là con đường. Nó sẽ luôn luôn phù hợp với regex ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. Bạn có thể kiểm tra đầu vào tiềm năng ở đây nếu bạn quan tâm.
• Bạn có thể nhận đầu vào ở 2 tham số của hàm hoặc chương trình, trong 2 tệp riêng biệt, từ STDIN hai lần hoặc từ chuỗi được phân tách bằng dấu cách được truyền đến STDIN, hàm, tệp hoặc tham số dòng lệnh.
• Nếu bạn muốn, bạn có thể thay đổi thứ tự của đầu vào.
• Có câu hỏi nào không? Hỏi dưới đây trong ý kiến ​​và hạnh phúc mã golf !

05AB1E , 24 22 byte

Trả về 1 khi chắc chắn tăng tốc và 0 nếu không.

Đã lưu 2 byte nhờ tính toán carusocomputing .

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

Hãy thử trực tuyến!

-§'-åkhông nên có nhiều hơn một so sánh đơn giản, nhưng vì một số lý do, dường như ›không ‹hoạt động giữa giá trị tính toán và đầu vào thứ hai.

Giải trình

Sử dụng 3.0==========20===, 3.2làm ví dụ

'=¡                        # 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

Python 2 , 71 byte

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

Hãy thử trực tuyến!

Hệ thống loại động của Python có thể có một số lạm dụng.

Việc tách chuỗi đầu vào s.split('=')sẽ biến kcác dấu bằng bằng thành k-1các phần tử danh sách chuỗi rỗng (ngoại trừ ở phần cuối, trong đó một phần phải được cắt bỏ). Ví dụ,

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

Mã lặp lại trên các phần tử này, cập nhật tốc độ hiện tại smỗi khi nó nhìn thấy một số. Bản cập nhật được thực hiện dưới dạng s=float(c or s), trong đó nếu clà một chuỗi không trống, chúng ta sẽ nhận được float(c), và nếu không thì c or sđánh giá đến s, nơi float(s)chỉ giữ s. Lưu ý rằng đó clà một chuỗi và slà một số, nhưng Python không yêu cầu không yêu cầu các kiểu đầu vào nhất quán và floatchấp nhận.

Cũng lưu ý rằng biến slưu trữ tốc độ giống như lấy chuỗi đầu vào. Chuỗi được đánh giá khi vòng lặp bắt đầu và việc thay đổi nó trong vòng lặp không thay đổi những gì được lặp lại. Vì vậy, cùng một biến có thể được sử dụng lại để lưu vào một khởi tạo. Vòng lặp đầu tiên luôn có cmột số, vì vậy s=float(c or s)không quan tâm đến svai trò ban đầu của một chuỗi.

Mỗi lần lặp lại trừ tốc độ hiện tại khỏi mức cho phép, bắt đầu là giới hạn tốc độ. Cuối cùng, giới hạn tốc độ đã bị vi phạm nếu điều này giảm xuống dưới 0.

Python 3 , 79 byte

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

Hãy thử trực tuyến!

Ví dụ: đầu vào 3.0==========20===được chuyển đổi thành chuỗi

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

và được đánh giá, và kết quả được so sánh với tốc độ đầu vào. Mỗi lần -~tăng theo 1. Tôi chưa quen với regexes, vì vậy có lẽ có một cách tốt hơn, như thực hiện cả hai sự thay thế cùng một lúc. Cảm ơn Jonathan Allan đã chỉ ra làm thế nào để phù hợp với tất cả trừ =nhân vật.

Javascript (ES6), 63 byte

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

Sử dụng

Gán hàm này cho một biến và gọi nó bằng cú pháp currying. Đối số đầu tiên là thời gian, thứ hai là con đường.

Giải trình

Khớp tất cả các lần chạy liên tiếp của các ký tự không có dấu bằng nhau, theo sau là một dấu bằng. Mỗi trận đấu được thay thế bằng kết quả của hàm bên trong, sử dụng hai đối số: chạy các dấu bằng (trong biến d) và số (biếnc ). Hàm trả về độ dài của đường được chia theo số, được thêm bởi dấu +.

Chuỗi kết quả sau đó được đánh giá và so sánh với đầu vào đầu tiên.

Đoạn trích

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>

GNU C, 128 byte

#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;}

Xử lý giới hạn tốc độ không nguyên cũng có. #import<stdlib.h>là cần thiết cho trình biên dịch không cho rằng atof()trả về mộtint .

t<s-.001là cần thiết để làm cho trường hợp kiểm tra giới hạn tốc độ chính xác hoạt động, nếu không các lỗi làm tròn khiến nó nghĩ rằng bạn đang tăng tốc. Tất nhiên, bây giờ nếu thời gian 1.4999thay vì 1.5, nó không xem xét việc tăng tốc. Tôi hy vọng điều đó ổn.

Hãy thử trực tuyến!

Perl 5 , 43 byte

42 byte mã + -pcờ.

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

Hãy thử trực tuyến!

Đối với mỗi nhóm chữ số theo sau bởi một số dấu bằng ( [^=]+(=+)), chúng tôi tính toán thời gian cần thiết để vượt qua nó (số lượng bằng cách chia cho tốc độ (length$1)/$&:) và tính tổng số lần đó bên trong $t. Cuối cùng, chúng tôi chỉ cần kiểm tra $tít hơn thời gian bạn đã sử dụng để vượt qua nó ( $_=$t < <>). Kết quả sẽ là 1(đúng) hoặc không có gì (sai).

Toán học, 98 byte

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

Hàm thuần túy lấy hai đối số, một số (có thể là số nguyên, phân số, thập phân, chẵn πhoặc một số trong ký hiệu khoa học) và một chuỗi kết thúc dòng mới, và trả về Truehoặc False. Giải thích bằng ví dụ, sử dụng các đầu vào 3.2và"3==========20===\n" :

#2~StringSplit~"="sản xuất {"3","","","","","","","","","","20","","","\n"}. Lưu ý rằng số ""s liên tiếp ít hơn một số liên tiếp= s trong mỗi lần chạy.

//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}là một quy tắc thay thế lặp đi lặp lại. Đầu tiên nó đặt zvào chuỗi rỗng, ađể "3", bđể "","","","","","","","",""(chạy dài nhất của ""s nó có thể tìm thấy), và cđến "20","","","\n"; lệnh (Length@{b}+1)/ToExpression@ađánh giá (9+1)/3và do đó, kết quả của sự thay thế là danh sách {10/3, "20","","","\n"}.

Tiếp theo các bộ quy tắc thay thế zđể 10/3, ađến "20", bđể "","", và cđể "\n". Bây giờ (Length@{b}+1)/ToExpression@ađánh giá (2+1)/20, và do đó, kết quả của sự thay thế là {10/3, 3/20, "\n"}. Quy tắc thay thế không thể tìm thấy kết quả khớp khác, vì vậy nó dừng lại.

Cuối cùng, Tr[...]-"\n"(nó tiết kiệm một byte để sử dụng một dòng mới thực sự giữa các dấu ngoặc kép thay vì "\n") thêm các yếu tố của danh sách, thu được 10/3 + 3/20 + "\n", và sau đó trừ đi "\n", điều mà Mathicala hoàn toàn hài lòng. Cuối cùng, <=#so sánh kết quả với đầu vào đầu tiên ( 3.2trong trường hợp này), sẽ mang lại kết quả False.

Thạch , 27 byte

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

Hãy thử trực tuyến!

Lưu ý: giả định rằng regex được đưa ra trong câu hỏi cần được như vậy mà một giới hạn tốc độ không thể 0.0, 0.00vv - giống như nó không thể được 0( xác nhận như một tài sản không chủ ý).

Làm sao?

ṣ”=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)

Python 3, 90 byte

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

Đầu ra True nếu bạn đang tăng tốc, Falsenếu bạn có thể không. Không yêu cầu (nhưng sẽ làm việc với) dòng mới.

Mặc dù trông không giống như vậy, nhưng nó xử lý chính xác các số float trong cả giới hạn thời gian và tốc độ đầu vào, bởi vì regex chỉ được sử dụng để ngăn cách các đoạn đường.

MATL , 31 30 byte

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

Đầu vào là: một chuỗi (giới hạn tốc độ và đường), sau đó là một số (tốc độ được sử dụng). Đầu ra là 1nếu chắc chắn tăng tốc, 0nếu không.

Hãy thử trực tuyến!

Giải thích với ví dụ

Xem xét đầu vào '3.0==========20==='và 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

APL, 41 byte

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

Điều này lấy đường là một chuỗi làm đối số bên phải của nó và thời gian là đối số bên trái của nó và trả về 1nếu bạn đang tăng tốc và 0nếu không, như vậy:

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

Giải trình:

• X←⍵='=': lưu trữ trong Xmột vectơ bit của tất cả các vị trí trong ⍵đó là một phần của đường.
• X≠¯1⌽X: đánh dấu từng vị trí của X không bằng với hàng xóm bên phải của nó (bao quanh), đưa ra các vị trí bắt đầu số và đường
• Y←⍵⊂⍨: phân chia ⍵tại các vị trí này (đưa ra một mảng các chuỗi số và đường xen kẽ) và lưu trữ nó vào Y.
• Y⊂⍨2|⍳⍴Y: chia ra Y các cặp liên tiếp.
• {(≢⍵)÷⍎⍺}/¨: cho mỗi cặp, chia chiều dài của phần đường ( ≢⍵) cho kết quả đánh giá phần số (⍎⍺ ). Điều này cho thời gian tối thiểu cho mỗi phân khúc.
• +/: Tính tổng thời gian cho tất cả các phân khúc để có được tổng thời gian tối thiểu.
• ⍺<: Kiểm tra xem thời gian đã cho có nhỏ hơn mức tối thiểu hay không.

TI-Basic, 168 165 byte

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

Đầu vào là đường như Str0và thời gian như T. Hãy chắc chắn đi trước con đường với một trích dẫn, ví dụ Str0=?"14========3===.

Đầu ra là 0 nếu tăng tốc, 1 nếu không thể tăng tốc.

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

Bash, 151 byte

Chạy dưới dạng (ví dụ) $ 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"` != -* ]]

Giải trình

shopt -s extglob
r=$2

Cho phép các toán tử khớp mẫu mở rộng của bash và gán đường cho một biến r.

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

Vòng lặp cho đến khi rtrống rỗng. Đặt fthành rvới tất cả các dấu bằng được loại bỏ từ cuối, sử dụng khai %% triển tham số và +()toán tử nối tiếp mở rộng.

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

Chỉ định stổng số lần chạy tối thiểu cho từng đoạn đường. Điều này có thể được viết lại (có lẽ một chút) dễ đọc hơn như:

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

Về cơ bản những gì đang diễn ra ở đây là chúng ta đang sử dụng một chuỗi ở đây để nhận dclệnh làm toán cho chúng ta, vì bash không thể tự mình thực hiện số học dấu phẩy động. 9kđặt độ chính xác sao cho phép chia của chúng ta là dấu phẩy động và pin kết quả khi chúng ta hoàn thành. Đó là một máy tính đánh bóng ngược, vì vậy những gì chúng tôi thực sự tính toán được ${f##*=}chia cho $[${#r}-${#f}], cộng với tổng hiện tại của chúng tôi (hoặc, khi chúng tôi mới chạy qua và schưa được đặt, không có gì, điều đó cho chúng tôi một thông báo cảnh báo về stderr về dc' ngăn xếp của chúng trống, nhưng nó vẫn in đúng số vì dù sao chúng ta sẽ thêm vào số 0).

Đối với các giá trị thực tế chúng tôi chia: ${f##*=}là fvới mẫu phù hợp lớn nhất được *=xóa khỏi mặt trước. Vì fđường hiện tại của chúng tôi có tất cả các dấu bằng bằng nhau được xóa từ cuối, nên phương tiện ${f##*=}này là giới hạn tốc độ cho đoạn đường đặc biệt này. Ví dụ: nếu đường của chúng tôi rlà '10 ===== 5 === ', thì fsẽ là '10 ===== 5', và vì vậy${f##*=} sẽ là '5'.

$[${#r}-${#f}]là số lượng các dấu hiệu bằng nhau ở cuối đoạn đường của chúng tôi. ${#r}là chiều dài của r; vì fchỉ rvới tất cả các dấu bằng ở cuối được loại bỏ, chúng ta chỉ có thể trừ chiều dài của nó từ đó rđể có chiều dài của đoạn đường này.

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

Xóa phần giới hạn tốc độ của đường này từ cuối f, để lại tất cả các phần khác của đường và đặt rở đó, tiếp tục vòng lặp để xử lý đoạn đường tiếp theo.

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

Kiểm tra xem thời gian chúng tôi đi du lịch trên đường (được cung cấp như $1 ) có thấp hơn mức tối thiểu cho phép theo giới hạn tốc độ hay không. Tối thiểu này s, có thể là một float, vì vậy chúng tôi chuyển sang dcmột lần nữa để làm so sánh. dckhông có toán tử so sánh, nhưng thực tế sử dụng nó đã kết thúc nhiều hơn 9 byte so với điều này, vì vậy thay vào đó tôi trừ đi thời gian di chuyển của chúng tôi từ mức tối thiểu và kiểm tra xem liệu nó có âm không bằng cách kiểm tra xem nó có bắt đầu bằng dấu gạch ngang không. Có lẽ không hay, nhưng tất cả đều công bằng trong tình yêu và cá tuyết.

Vì kiểm tra này là lệnh cuối cùng trong tập lệnh, nên giá trị trả về của nó cũng sẽ được trả về bởi tập lệnh: 0 nếu có thể tăng tốc, 1 nếu chắc chắn tăng tốc:

$ 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

Python 3.6, 111 byte

Golf mã đầu tiên của tôi!

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

Hãy thử trực tuyến!

re.split('(=+)',b)[:-1] Tách đường bằng những khúc = .

Sau đó, nó lặp lại kết quả, sử dụng try:s=float(c)để đặt giới hạn tốc độ hiện tại nếu mục hiện tại là một số hoặcexcept:t+=len(c)/s để thêm thời gian để đi qua đoạn đường này vào tổng số tích lũy.

Cuối cùng, nó trả về thời gian thực hiện đến thời gian nhanh nhất có thể.

PHP5 207 202 byte

Nỗ lực đầu tiên tại một câu trả lời golf mã, xin vui lòng đi dễ dàng với tôi. Tôi chắc rằng một trong những thiên tài của bạn sẽ có thể rút ngắn điều này một cách đáng kể, bất kỳ mẹo chơi gôn nào đều được chào đón.

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;}

Gọi với

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

Trả về true nếu bạn đã ở dưới giới hạn tốc độ, sai nếu không

APL Dyalog, 27 byte

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

'=+'⎕s 1là một hàm xác định các trải dài '='với biểu thức chính quy và trả về một vectơ có độ dài của chúng ( ⎕stoán hạng bên phải 0 có nghĩa là độ lệch; 1 - độ dài; 2 - chỉ số của biểu thức khớp khớp)

'='⎕r' 'thay thế '='s bằng dấu cách

⍎'='⎕r' ' thực thi nó - trả về một vectơ tốc độ

÷⍨ ở giữa chia hai vectơ (⍨ hoán đổi các đối số, do đó, khoảng cách chia cho tốc độ)

+/ là tổng

tất cả mọi thứ cho đến nay là 4 tàu - một chức năng không có đối số rõ ràng

<∘soạn "ít hơn" trước hàm đó; vì vậy, hàm sẽ chỉ hành động theo đối số bên phải và kết quả của nó sẽ được so sánh với đối số bên trái

F # (165 byte)

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

Tôi vẫn chưa quen với F #, vì vậy nếu tôi làm bất cứ điều gì kỳ lạ hoặc ngu ngốc, hãy cho tôi biết.

Phương thức C # ( 137 122 byte)

Yêu cầu using System.Linqthêm 19 byte, bao gồm trong 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;

Phiên bản mở rộng:

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

Các roadchuỗi được chia trên =nhân vật. Tùy thuộc vào việc một chuỗi có phải là mảng kết quả không, hàm tổng hợp sẽ đặt pacebiến cho phân đoạn (biểu thị thời gian cần thiết để di chuyển một chuỗi =) và trừ nó khỏi thời gian được cung cấp. Điều này sẽ thực hiện quá nhiều phân đoạn (cho đoạn đường cuối cùng), vì vậy thay vì so sánh với 0, chúng tôi so sánh với-pace

R , 100 byte

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])}

Hãy thử trực tuyến!

Trả về TRUEcác giá trị tăng tốc rõ ràng, FALSEcho các giá trị không cần thiết.

PowerShell , 71 byte

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

Hãy thử trực tuyến!

Kịch bản thử nghiệm:

$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"
}

Đầu ra:

True: False
True: True

Giải trình:

1. Kịch bản nhận các phần tử của đường 5=====10=====, hoán đổi các phần tử, thêm dấu ngoặc và toán tử+(=====)/5+(=====)/10
2. Sau đó, tập lệnh thay thế từng =bằng +1:+(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
3. Cuối cùng, tập lệnh đánh giá chuỗi dưới dạng biểu thức Powershell và so sánh nó với đối số đầu tiên.