İyi bir sanat yolu ve onu geçmem için gereken süre göz önüne alındığında, hızlanıp hızlanmadığımı söyle.

Birimler

Mesafe keyfi biriminde d. Zaman keyfi biriminde t.

Yol

İşte basit bir yol:

10=====

10Aracı 10 dher t. Bu yolun hız sınırıdır. Yol 5 sahiptir =onun kadar, s dı 0.5 bu yol çapraz Bu nedenle, 5'tir t, I 10 çıktı dbaşına t5 / 0.5 = 10 bu yolun hız sınırı 10, çünkü hız sınırı içinde kaldı, böylece.

I o yol çapraz Ancak 0.25 t , 20 çıktı dbaşına t5 /, çünkü 0.25 = 20 bu yolun hız sınırı 10 I hız sınırı üzerinde 10 gitti.

Örnekler ve hesaplamalar

Unutmayın ki 1 girişi, yolu seyahat etmek için harcadığım süre ve 2 girişi de yolun kendisidir.

İşte karmaşık bir yol:

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

İlk yoldan (yasal olarak) çıkabileceğim en hızlı =olanı (ilk 5 sn) d5'tir t. 5'e (mesafe) 5'e (hız sınırı) bölünen 1 olduğu için, o yolda gidebileceğim en hızlı 1'dir t.

Bir sonraki yolda, hız sınırı 10 ve mesafe de 5'tir, en hızlı 0,5 (5/10) olanı geçebilirim. Minimum sürelerin toplamı 1.5 ile sonuçlanır, bu da tam olarak hız sınırına ulaştım.

Not: Biliyorum, bir yolda gerçekten hızlı gidiyor olabilirim, diğerinde çok yavaş gidiyor ve hala 1.5'te geçiyor olabilirim, ama burada en iyisini kabul ediyorum.

Son bir örnek:

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

İlk yol 10 uzun ve 3'teki hız sınırına sahip, bu yüzden minimum süre 3.33333 ... (10/3)

İkinci yol 3 uzun ve hız sınırı 20, bu nedenle minimum süre 0,15 (3/20).

Zamanların toplamı 3.483333333 olarak sonuçlandı ... 3,2'de çarpıştım, bu yüzden bir yere basmalıydım.

Notlar:

• Kuşkusuz hızlanıyorsam bir değeri, olmasam bile başka bir değeri çıkarmalısınız.
• Programınız veya işleviniz, izleyen bir yeni hattın girilmesi için girdi veya çıktı gerektirebilir, ancak lütfen gönderiminizde bunu söyleyin.
• İlk girişiniz benim hızım olacak. Olumlu bir kayan nokta veya tam sayı veya dize olacak.
• İkinci girişiniz yol olacak. Her zaman regex ile eşleşir ^(([1-9]+[0-9]*|[0-9]+\.[0-9]+)=+)+\n?$. İlgileniyorsanız, potansiyel girişleri burada test edebilirsiniz.
• Bir fonksiyon veya programın 2 parametresinde, 2 ayrı dosyada, iki kez STDIN'den veya STDIN'e, bir fonksiyondan, bir dosyadan veya komut satırı parametresinden geçen boşlukla ayrılmış bir dizgeden girdi alabilirsiniz.
• İsterseniz, girişlerin sırasını değiştirebilirsiniz.
• Sorusu olan? Yorumlar ve mutlu kod-golf ing!

05AB1E , 24 22 bayt

İade 1 kuşkusuz hız ve 0 aksi.

Carusocomputing sayesinde 2 bayt kurtardı .

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

Çevrimiçi deneyin!

-§'-åbasit bir karşılaştırmadan daha fazlası olması gerekmemeli, ancak bir nedenden dolayı hesaplanan değer ile ikinci girdi arasında ›ne ‹işe yaradığı görünmüyor.

açıklama

3.0==========20===, 3.2Örnek olarak kullanmak

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

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

Çevrimiçi deneyin!

Python'un dinamik tip sistemi biraz suistimal alabilir.

Yarma giriş dizesi s.split('=')döner kiçine eşittir işareti k-1(bir kesilmelidir sonunda hariç) boş dize listesi elemanları. Örneğin,

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

Kod, sher eleman gördüğünde geçerli hızı güncelleyerek bu elemanların üzerinde yinelenir . Olarak güncelleme yapılır s=float(c or s)eğer nerede, cboş olmayan bir dize, biz olsun float(c)aksi ve c or sdeğerlendirir snerede, float(s)sadece tutar s. Bunun cbir dize ve sbir sayı olduğunu unutmayın; ancak Python gerektirmeyen tutarlı girdi türleri gerektirmez ve floatikisini de kabul eder.

Ayrıca s, hızı kaydeden değişkenin giriş dizesini almakla aynı olduğuna dikkat edin. Dize, döngü başladığında değerlendirilir ve onu döngü içinde değiştirmek yinelenen şeyi değiştirmez. Bu nedenle, bir başlatma işleminde tasarruf etmek için aynı değişken yeniden kullanılabilir. İlk döngü her zaman cbir sayıya sahiptir, bu nedenle bir dizge olarak başlangıçtaki rolünü s=float(c or s)önemsemez s.

Her yineleme, mevcut hızı, hız sınırı olarak başlayan ödenekten çıkartır. Sonunda, eğer bunun altına düşerse, hız sınırı ihlal edilmiştir 0.

Python 3 , 79 bayt

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

Çevrimiçi deneyin!

Örneğin, giriş 3.0==========20===dizgeye dönüştürülür.

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

değerlendirildi ve sonuç giriş hızı ile karşılaştırıldı. Her -~artışla 1. Regexes için yeniyim, bu yüzden belki de her ikisini de aynı anda yapmak gibi daha iyi bir yol var. Jonathan Allan'a, =karakter dışındaki herkesle nasıl eşleşileceğini gösterdiği için teşekkürler .

Javascript (ES6), 63 bayt

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

kullanım

Bu işlevi bir değişkene atayın ve körleme sözdizimini kullanarak çağırın. İlk argüman zaman, ikincisi yoldur.

açıklama

Eşit işaret olmayan ardışık tüm karakter dizilerini takip eder, ardından eşit işaretler dizisiyle eşleşir. Her eşleşme, iki argüman kullanan iç fonksiyonun sonucuyla değiştirilir: eşit işaretlerin çalışması (değişkende d) ve sayı (değişken c). İşlev, + işaretiyle numaralandırılmış yolun uzunluğunu döndürür.

Elde edilen dize daha sonra değerlendirilir ve ilk girdiyle karşılaştırılır.

Yığın Parçacığı

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 bayt

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

Tamsayılı olmayan hız sınırlarını da işler. #import<stdlib.h>derleyicinin atof()bir döndürdüğünü varsaymaması için gereklidir int.

t<s-.001Kesin hız limiti test durumunun çalışması için gereklidir, aksi halde yuvarlama hataları hızlandığınızı düşünmesine neden olur. Tabii ki, şimdi zaman 1.4999yerine 1.5, o zaman bu hız dikkate almaz. Umarım herşey yolundadır.

Çevrimiçi deneyin!

Perl 5 , 43 bayt

42 bayt kodu + -pbayrak.

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

Çevrimiçi deneyin!

Ardından gelen her hane grubu ve bazı eşit işaretler ( [^=]+(=+)) için, onu geçmek için ne kadar zamana ihtiyaç duyulduğunu (hıza bölünen eşittir sayısı) hesaplar (length$1)/$&ve içerisindeki süreleri toplar $t. Sonunda, sadece $tonu geçmek için harcadığınız zamandan daha azını kontrol etmemiz gerekir ( $_=$t < <>). Sonuç 1(doğru) veya hiçbir şey (yanlış) olacaktır.

Mathematica, 98 bayt

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

İki argüman alarak bir sayı (bir tam sayı, kesir, ondalık, hatta πveya bilimsel gösterimde bir sayı olabilir) ve yeni satır sonlandırılmış bir dize ve döndürme TrueveyaFalse . Örnek olarak, girişler kullanılarak açıklama 3.2ve "3==========20===\n":

#2~StringSplit~"=" üretir {"3","","","","","","","","","","20","","","\n"} . Her çalışmada ""ardışık =s sayısının bir ardışık s sayısından daha az olduğuna dikkat edin .

//.{z___,a_,b:Longest@""..,c__}:>{z,(Length@{b}+1)/ToExpression@a,c}yinelenen bir değiştirme kuralıdır. Önce ayarlar z, boş dizisine aiçin "3", biçin "","","","","","","","",""(en uzun vadede ""s o bulabildiğim) ve ckarşı "20","","","\n"; komuta(Length@{b}+1)/ToExpression@a değerlendirilir (9+1)/3ve bu nedenle değiştirmenin sonucu listedir {10/3, "20","","","\n"}.

Yedek kural kümeleri Sonraki zetmek 10/3, aiçin "20", biçin "","", ve ciçin "\n". şimdi(Length@{b}+1)/ToExpression@a değerlendirir (2+1)/20ve bu nedenle yerine geçer {10/3, 3/20, "\n"}. Değişim kuralı başka bir eşleşme bulamıyor, bu yüzden durdu.

Son olarak, Tr[...]-"\n"(tırnak işaretleri arasında gerçek bir yeni satır kullanmak için bir bayt kazandırır "\n") listenin öğelerini ekler, elde eder 10/3 + 3/20 + "\n"ve sonra "\n"Mathematica'nın yapmaktan çok mutlu olduğu şeyleri çıkarır . Son olarak, <=#sonucu veren ilk girişle ( 3.2bu durumda) karşılaştırır False.

Jöle , 27 bayt

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

Çevrimiçi deneyin!

Not: Söz verilen regex bir hız sınırı olamaz böyle olması gerektiğini varsayar 0.0, 0.00- bu olamaz gibi vb 0( teyit bir kasıtsız özelliği olarak).

Nasıl?

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

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

Çıkışlar TrueEğer hız eğer Falsesen olmayabilir eğer. Sondaki yeni satırı gerektirmez (ancak çalışacaktır).

Olması gerektiği gibi görünmemesine rağmen, hem giriş zamanı hem de hız sınırlarında yüzmeleri doğru şekilde işler, çünkü regex sadece yol bölümlerini ayırmak için kullanılır.

MATL , 31 30 bayt

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

Girişler: bir dize (hız sınırları ve yollar), sonra bir sayı (kullanılan hız). Çıktı 1şüphesiz ki hızlanıyorsa 0olmasın.

Çevrimiçi deneyin!

Örnek ile açıklama

Girdileri düşünün '3.0==========20==='ve 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 bayt

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

Bu, yolu doğru argüman olarak bir dize ve sol argüman olarak geçen zaman alır ve 1hız yapıyorsanız ve 0böyle yapmazsanız geri döner :

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

Açıklama:

• X←⍵='=': Xiçindeki tüm konumların bir bit vektöründe saklayın⍵ .
• X≠¯1⌽X: Her bir pozisyonunu Xsağ komşusuna eşit değil (etrafına sarılarak) işaretleyin, sayıların ve yolların başladığı pozisyonları verin
• Y←⍵⊂⍨: ⍵bu konumlara bölün (bir dizi değişken sayı ve yol dizileri vererek) ve saklayın Y.
• Y⊂⍨2|⍳⍴Y: Yardışık çiftler halinde ayrılma .
• {(≢⍵)÷⍎⍺}/¨: her çift için, ( ≢⍵) sayısını değerlendirerek yol bölümünün uzunluğunu ( ) bölün ⍎⍺. Bu, her segment için minimum zamanı verir.
• +/: Tüm bölümlerin toplam asgari süreye ulaşma sürelerini toplayın.
• ⍺<: Verilen zamanın minimumdan düşük olup olmadığını kontrol edin.

TI-Basic, 168 165 bayt

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

Giriş, olduğu gibi Str0ve giden yoldur T. Yol tarifinden önce bir alıntı yaptığınızdan emin olun, örn Str0=?"14========3===.

Hız yüksekse 0, hız yüksek değilse 1'dir.

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 bayt

Olarak çalışıyor (örneğin) $ 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"` != -* ]]

açıklama

shopt -s extglob
r=$2

Bash'in genişletilmiş kalıp eşleştirme işleçlerini etkinleştirin ve yolu bir değişkene atayın r.

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

rBoş olana kadar döngü . Set fiçin rtüm eşit işaretler kullanılarak ucundan çıkarılmış olan %% parametre genişleme ve +()genişletilmiş globbing operatör.

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

sHer yol segmenti için minimum sürelerin toplamını atayın . Bu, şu şekilde daha okunaklı olarak yeniden yazılabilir (belki de biraz):

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

Temelde burada olan, bizim için dcmatematik yapma komutunu almak için bir here-string kullanıyoruz , çünkü bash kendisi tarafından kayan nokta aritmetiği yapamıyor. 9khassasiyeti, bölümümüzün kayan nokta olması için ayarlar ve pbitirdiğimizde sonucu yazdırır. Bu bir ters-cila hesaplayıcısıdır, yani gerçekten hesapladığımız şey ${f##*=}bölüdür $[${#r}-${#f}], artı şimdiki toplamımızdır (ya da ilk kez çalıştığımızda ve shenüz kurulmadığında, bize stderr hakkında bir uyarı mesajı veren hiçbir şey yoktur dc'. yığının boş olmasına rağmen, yine de doğru sayıyı yazdırıyor çünkü yine de sıfıra ekliyoruz).

Biz bölüyorlar gerçek değerler gelince: ${f##*=}bir fbüyük desen eşleştirme ile *=önden kaldırıldı. Bu yana fbu araçlar, ucundan çıkarılmış hepsi eşit işaretleri ile mevcut yol ${f##*=}yolun bu kısmında için hız sınırıdır. Örneğin, eğer ryolumuz '10 ===== 5 === ' folsaydı , o zaman '10 ===== 5' ${f##*=}olacaktı ve '5' olacaktı.

$[${#r}-${#f}]yolumun sonundaki eşit işaretlerin sayısıdır. ${#r}uzunluğu r; çünkü fadildir rkaldırıldı sonunda tüm eşit işaretleri ile, sadece bunun onun uzunluğunu çıkarma rBu yolun bir bölümünün uzunluğunu alır.

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

Yolun hız sınırının bu bölümünü, yolun fdiğer tüm kısımlarını bırakarak sondan itibaren kaldırın ve rbuna bir sonraki yol parçasını işlemek için döngüyü devam ettirerek ayarlayın .

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

Yola yolculuk ettiğimiz sürenin (olduğu gibi $1) hız sınırının izin verdiğinden düşük olup olmadığını kontrol edin. Bu minimum, sbir şamandıra olabilir, bu yüzden dckarşılaştırmayı yapmak için tekrar dönüyoruz . dcBir karşılaştırma operatörüne sahip, ancak aslında onu kullanmak 9'dan daha fazla bayt olarak sona ermiştir, bu yüzden seyahat süremizi en aza indiririm ve bir çizgi ile başlayıp başlamadığını kontrol ederek negatif olup olmadığını kontrol ederim. Belki tuhaf, ama hepsi aşık ve kodgolf'ta adil.

Bu kontrol koddaki son komut olduğundan, dönüş değeri kod tarafından da döndürülür: eğer hızlanıyorsa 0, kesinlikle hızlanıyorsa 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

Python 3.6, 111 bayt

İlk golf kodum!

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

Çevrimiçi deneyin!

re.split('(=+)',b)[:-1] Yolu parçalara böler =.

Ardından try:s=float(c), geçerli öğe bir sayıysa , geçerli hız sınırını ayarlamak veya except:t+=len(c)/sbu yolun kümülatif toplamına geçmek için zaman eklemek için kullanarak , hız üzerinden tekrar eder.

Sonunda, mümkün olan en kısa sürede geçen süreyi döndürür.

PHP5 207 202 bayt

Bir kod golf cevap ilk çaba, lütfen bana kolay gidin. Eminim sizlerden birileri bunu önemli ölçüde kıslatabilecektir, herhangi bir golf ipucu bekliyoruz.

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

İle çağır

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

Hız sınırının altındaysanız true, aksi takdirde false değerini döndürür

Dyalog APL, 27 bayt

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

'=+'⎕s 1 uzanıyor tanımlayan bir işlevdir '='bir regex ile ve uzunluklarının bir vektörünü döndüren ( ⎕s's' sağ operandı 0 ofset anlamına gelir; 1 uzunluklar; eşleşen 2 - regex indeksi)

'='⎕r' ''='s'yi boşluklarla değiştirir

⍎'='⎕r' ' çalıştırır - hız vektörünü döndürür

÷⍨ ortada iki vektörü böler (⍨ argümanları değiştirir, bu yüzden mesafe hıza bölünür)

+/ toplam

Şimdiye kadar her şey 4-tren - açık bir argüman olmadan bir işlev

<∘bu fonksiyonun önünde "az" kelimesini oluşturur; bu nedenle, işlev yalnızca doğru argümana göre hareket eder ve sonuçları sol argümana göre karşılaştırılır

F # (165 bayt)

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

Hala F # için yeniyim, bu yüzden garip ya da aptalca bir şey yaparsam bana bildirin.

C # yöntemi ( 137 122 bayt)

using System.Linq122'ye dahil edilen 19 bayt eklemeyi gerektirir :

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

Genişletilmiş sürüm:

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

roadDize üzerinde ayrılmıştır =karakteri. Bir dizgenin sonuçta elde edilen dizinin boş olup olmadığına bağlı olarak, toplama işlevi pacesegment için değişkeni ayarlar (bir tekin seyahat =etmesi için geçen süreyi gösterir) ve verilen zamandan çıkarır. Bu yüzden yerine göre karşılaştırmak yerine, (nihai yol segmenti için) bir çok substractions yapacağız 0, biz karşılaştırmak-pace

R , 100 bayt

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

Çevrimiçi deneyin!

İade TRUEaçıkça, değerlerini hızlandırmak için FALSEmuhtemelen unspeedy olanlar için.

PowerShell , 71 bayt

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

Çevrimiçi deneyin!

Test komut dosyası:

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

Çıktı:

True: False
True: True

Açıklama:

1. Senaryo yolun öğelerini alır, öğeleri 5=====10=====değiştirir, parantez ve operatör ekler+(=====)/5+(=====)/10
2. Sonra komut dosyası her biri =ile değiştirir +1:+(+1+1+1+1+1)/5+(+1+1+1+1+1)/10
3. Son olarak, komut dosyası dizgiyi Powershell ifadesi olarak değerlendirir ve ilk argümanla karşılaştırır.