아스키 아트 도로와 도로를 건너는 데 걸리는 시간을 감안할 때, 과속인지 말해주십시오.

단위

거리는의 임의의 단위입니다 d. 시간은의 임의의 단위입니다 t.

도로

간단한 길은 다음과 같습니다.

10=====

10수단 (10) d에 따라 t. 그것이 도로의 제한 속도입니다. 도로 5 가지고 =그 그래서, S를 dI 0.5에 해당 교차하는 경우, 따라서 5이며 t, I (10) 간 d당을 t5 / 0.5 = 10 즉 도로의 제한 속도가 10이기 때문에 I 제한 속도 내에 머물도록.

그러나 0.25 에서 해당 도로를 건너면 5 / 0.25 = 20 이기 때문에 t20 d당 갔습니다 . 해당 도로의 제한 속도는 10이므로 제한 속도를 넘어 10을 넘었습니다.t

예와 계산

입력 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?$. 관심이 있다면 여기에서 잠재적 인 입력을 테스트 할 수 있습니다.
• 함수 또는 프로그램의 두 매개 변수, 두 개의 개별 파일, STDIN에서 두 번 또는 STDIN으로 전달 된 공백으로 분리 된 문자열, 함수, 파일 또는 명령 행 매개 변수를 입력 할 수 있습니다.
• 원하는 경우 입력 순서를 변경할 수 있습니다.
• 질문 있습니까? 의견과 행복한 코드 골프 에서 아래에 물어보십시오 !

05AB1E , 24 22 바이트

반환 한 의심 할 여지없이 속도와 0 , 그렇지 않으면.

carusocomputing 덕분에 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

파이썬 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숫자이지만, 일관성있는 입력 유형을 필요로하지 않습니다 파이썬은 필요하지 않으며, float중 하나를 받아들입니다.

s속도를 저장 하는 변수 는 입력 문자열을받는 것과 같습니다. 루프가 시작될 때 문자열이 평가되며 루프 내에서 문자열을 변경해도 반복되는 내용은 변경되지 않습니다. 따라서 동일한 변수를 재사용하여 초기화에 저장할 수 있습니다. 첫 번째 루프는 항상 c숫자로 표시되므로 문자열의 초기 역할에 s=float(c or s)신경 쓰지 않습니다 s.

각 반복은 허용 한계에서 현재 속도를 빼고 속도 제한으로 시작합니다. 결국, 속도 제한이 아래로 떨어지면 제한 속도를 위반 한 것 0입니다.

파이썬 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. 나는 정규 표현식을 처음 사용하므로 두 번의 대체를 한 번에하는 것과 같은 더 좋은 방법이있을 수 있습니다. =캐릭터 를 제외한 모든 캐릭터 를 일치시키는 방법을 지적 해 주신 Jonathan Allan에게 감사드립니다 .

자바 스크립트 (ES6), 63 바이트

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

용법

이 함수를 변수에 할당하고 카레 구문을 사용하여 호출하십시오. 첫 번째 주장은 시간이고 두 번째 주장은 길입니다.

설명

등호가 아닌 연속 된 모든 문자와 일치하는 등호를 찾습니다. 각 일치 항목은 내부 함수의 결과로 대체되며, 두 개의 인수, 즉 등호 (변수 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>

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과속을 고려하지 않습니다. 나는 그것이 괜찮기를 바랍니다.

온라인으로 사용해보십시오!

펄 5 , 43 바이트

42 바이트의 코드 + -p플래그.

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

온라인으로 사용해보십시오!

각 자릿수 그룹과 그 뒤에 등호 ( [^=]+(=+))가있을 때, 우리는 그것을 가로 지르는 데 얼마나 많은 시간이 필요한지 (등가의 수를 속도로 나눈 (length$1)/$&값 :) 계산하고 그 시간을 내부에 합산합니다 $t. 결국, 우리 $t는 당신이 그것을 교차하는 데 걸리는 시간보다 짧은 것을 확인 하면됩니다 ( $_=$t < <>). 결과는 1(참) 또는 아무것도 아닙니다 (거짓)입니다.

수학, 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 의 수보다 1이 적습니다 .

//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}반복 교체 규칙입니다. 첫째는 설정 z, 빈 시퀀스 a에 "3", b에 "","","","","","","","",""(가장 긴 실행 ""의 IT 찾을 수), 및 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.

젤리 , 27 바이트

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

온라인으로 사용해보십시오!

참고 : 질문에 주어진 정규 표현식은 속도 제한이 될 수 없도록해야한다고 가정 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)

파이썬 3, 90 바이트

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

출력 True속도가 빠르면False 합니다. 후행 줄 바꿈이 필요하지 않지만 작동합니다.

정규식은 도로 세그먼트를 분리하는 데 사용되므로 입력 시간과 속도 제한 모두에서 플로트를 올바르게 처리합니다.

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

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연속 쌍으로 나눕니다 .
• {(≢⍵)÷⍎⍺}/¨: 각 쌍에 대해 도로 부분 ( ≢⍵) 의 길이를 숫자 부분 ( ⍎⍺) 을 평가 한 결과 로 나눕니다 . 이것은 각 세그먼트에 대한 최소 시간을 제공합니다.
• +/: 모든 최소 세그먼트 시간을 합하여 총 최소 시간을 얻습니다.
• ⍺<: 주어진 시간이 최소 시간보다 짧은 지 확인하십시오.

TI-기본, 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및 시간 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(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

배쉬, 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

bash의 확장 패턴 일치 연산자를 활성화 하고 도로를 변수에 할당하십시오 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")

기본적으로 여기서 일어나고있는 것은 dcbash가 부동 소수점 산술을 자체적으로 수행 할 수 없기 때문에 here-string을 사용하여 수학을 수행 하는 명령을 얻는 것입니다. 9k나누기가 부동 소수점이되도록 정밀도를 설정 p하고 완료되면 결과를 인쇄합니다. 그것은 역 폴란드어 계산기, 그래서 우리가 정말을 산출하는지 ${f##*=}나눈 $[${#r}-${#f}]플러스 우리가 처음 통해 실행하고 현재 합계 (또는, s대한 표준 에러에 우리에게 경고 메시지를 가져옵니다, 아직 아무것도 설정되어 있지 않은, dc' 스택은 비어 있지만 어쨌든 0에 더하기 때문에 여전히 올바른 숫자를 인쇄합니다.

우리가 분할하고있는 실제 값에 관해서는 : ${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

파이썬 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 하거나이 도로 섹션을 통과하는 시간을 누적 총계로 추가하는 데 .

마지막으로 가능한 시간을 가장 빠른 시간으로 되돌립니다.

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===")

제한 속도 미만이면 true를, 그렇지 않으면 false를 반환합니다.

Dyalog APL, 27 바이트

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

'=+'⎕s 1는 '='정규 표현식으로 스트레치를 식별 하고 길이의 벡터를 반환 하는 함수입니다 ( ⎕s'오른쪽 피연산자 0은 오프셋을 의미합니다; 1-길이; 2-일치 하는 정규 표현식 의 인덱스)

'='⎕r' ''='s를 공백으로 바꿉니다.

⍎'='⎕r' ' 그것을 실행-속도의 벡터를 반환

÷⍨중간에 두 벡터를 나눕니다 ( ⍨인수를 교환하므로 거리를 속도로 나눕니다)

+/ 합이다

지금까지의 모든 것은 4- 트레인입니다-명백한 인수가없는 함수

<∘해당 기능 앞에서 "보다 작음"을 구성합니다. 따라서 함수는 오른쪽 인수에만 작용하고 결과는 왼쪽 인수와 비교됩니다.

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 #을 처음 사용하기 때문에 이상하거나 어리석은 짓을했다면 알려주십시오.

C # 방법 ( 137122 바이트)

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

R , 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아마도 속도가 느린 값을 반환 합니다.

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 표현식으로 평가하여 첫 번째 인수와 비교합니다.