একটি অসি-আর্ট রাস্তা দেওয়া হয়েছে এবং এটিটি পেরোতে আমার যে সময় লেগেছিল, আমি দ্রুত বলছি কিনা তা বলুন।

ইউনিট

দূরত্বটি স্বেচ্ছাসেবকের ইউনিটে d। সময় নির্বিচারে ইউনিট হয় t।

রাস্তাটি

এখানে একটি সাধারণ রাস্তা:

10=====

10মানে 10 dপ্রতি t। এটাই রাস্তার গতির সীমা। রাস্তাটির 5 =টি রয়েছে, সুতরাং এর d5 টি Therefore সুতরাং, আমি যদি এই রাস্তাটি 0.5 তে অতিক্রম করি তবে আমি প্রতি t10 পেয়েছি , কারণ 5 / 0.5 = 10 road রাস্তার গতির সীমা 10, তাই আমি গতির সীমাতে রয়েছি।dt

তবে আমি যদি 0.25-এ রাস্তাটি অতিক্রম করি তবে আমি প্রতি t20 পেয়েছি কারণ 5 / 0.25 = 20। রাস্তার গতির সীমা 10, সুতরাং আমি গতির সীমা ছাড়িয়ে 10 গিয়েছিলাম 10dt

উদাহরণ এবং গণনা

নোট করুন যে ইনপুট 1 হ'ল আমি রাস্তাটি ভ্রমণ করতে গিয়েছিলাম এবং ইনপুট 2 হ'ল রাস্তাটি।

এখানে একটি জটিল রাস্তা:

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

প্রথম রাস্তায় আমি (আইনীভাবে) সবচেয়ে দ্রুত যেতে পারলাম (প্রথম 5 =টি) dপ্রতি 5 জন 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.) হয়

মোট সময়ের ফলাফল ৩.৪৪৩৩৩৩৩৩৩ ... আমি এটিকে ৩.২ এ অতিক্রম করেছি, তাই আমাকে কোথাও গতিতে চলতে হয়েছিল।

নোট:

আমি অবশ্যই নিঃসন্দেহে গতিশীল হলে একটি পৃথক মান আউটপুট করতে হবে এবং আমি নাও হতে পারলে অন্য একটি আলাদা মান value
আপনার প্রোগ্রাম বা ফাংশনটির জন্য একটি ইনপুট বা আউটপুট দরকার হতে পারে একটি অনুচরীন নতুন লাইন থাকতে পারে তবে দয়া করে আপনার জমা দেওয়ার ক্ষেত্রে এটি বলুন।
আপনার প্রথম ইনপুটটি আমার গতি হবে। এটি একটি ইতিবাচক ভাসা বা পূর্ণসংখ্যা বা স্ট্রিং হবে।
আপনার দ্বিতীয় ইনপুটটি হবে রাস্তা। এটি সর্বদা রেজেক্সের সাথে মিলবে ^(([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?$। (এটি চেহারাটির পিছনে পরিষ্কার ছিল তবে তার জন্য এটির প্রয়োজন হবে। নেট ইঞ্জিন)

— দাদা

6

05 এ বি 1 ই , 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

@ovs: .Sকাজ করে, ঠিক আছে। এটি 2 অনন্য মানগুলি ফেরত দেয় না যদিও এটি 0 ফিরে আসবে যখন আপনি ঠিক গতির সীমাটি সম্পন্ন করেছেন।

— এমিগানা

1

@ এমিগনা গাহ ... আমি ভুল পোস্ট করছি; a > bঅপারেটর একটি float এবং কোন int মধ্যে তুলনা করার আগে পূর্ণসংখ্যা এ কাস্ট করছে। এটা খুবই অদ্ভুত প্রকৃতপক্ষে ... আমি 22 বাইট যদিও এটিকে নিচে পেতে পারি: '=¡€Þ¹S'=Q.¡O0K/O-§'-å।

— ম্যাজিক অক্টোপাস উরন

@ কারাসোকম্পুটিং: দুর্দান্ত! সংক্ষেপে চুঙ্কিফাই করা একটি ভাল ধারণা ছিল।

— এমিগানা

@ কারাসোকম্পিউটিং: মুছে ফেলার আগে আপনার চূড়ান্ত সংস্করণটি 2 রিটার্ন মান সহ 23 '= ¡.¡2ôvy g>s/} O-§'-to এ সংক্ষিপ্ত করে 23 করা যেতে পারে। এখনও সেখানে কিছু উন্নতি হতে পারে? আমি কি দেখছি না। এই শেষ তুলনা সত্যিই আমাদের স্ক্রু আপ।

— এমিগিনা

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('=')সক্রিয় 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সংরক্ষণের গতিটি ইনপুট স্ট্রিংয়ের মতো একই as লুপটি শুরু হওয়ার সাথে সাথে স্ট্রিংটি মূল্যায়ন করা হয় এবং লুপের মধ্যে এটি পরিবর্তন করা যা পুনরাবৃত্ত হয় তা পরিবর্তন করে না। সুতরাং, একই ভেরিয়েবলটি একটি আরম্ভের ক্ষেত্রে সংরক্ষণ করতে পুনরায় ব্যবহার করা যেতে পারে। প্রথম লুপটিতে সর্বদা 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। আমি রেইজেক্সে নতুন, তাই সম্ভবত আরও ভাল উপায় আছে, একইসাথে উভয় বিকল্প তৈরির মতো। =চরিত্রটি ছাড়াও কীভাবে সব মিলিয়ে যায় তা নির্দেশ করার জন্য জোনাথন অ্যালানকে ধন্যবাদ ।

— xnor
সূত্র

এটি এখনও ভাসমান পরিচালনা করতে সক্ষম হবে বলে মনে হচ্ছে না।

— L3viathan

@ L3viathan আপনি কি উদাহরণ দিতে পারেন যেখানে এটির ভুল হয়?

— xnor

উদাহরণস্বরূপ যখন রাস্তাটি হয় "0.5=20===", আউটপুট Noneসময় ইনপুট নির্বিশেষে হবে ।

— L3viathan

আহ, শূন্য দ্বারা ভাগ করুন ...

— জোনাথন অ্যালান

আমি মনে করি ([\d|.]+)এটি ঠিক করতে পারে।

— জোনাথন অ্যালান

6

জাভাস্ক্রিপ্ট (ES6), 63 বাইট

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

ব্যবহার

এই ফাংশনটি একটি ভেরিয়েবলকে বরাদ্দ করুন এবং কারিঙ সিনট্যাক্স ব্যবহার করে এটি কল করুন। প্রথম যুক্তিটি সময়, দ্বিতীয়টি রাস্তা।

ব্যাখ্যা

অক্ষরগুলির ক্রমাগত সমস্ত রানের সমান চিহ্ন যা সমান চিহ্নের একটি রান পরে সমান চিহ্ন নয়। প্রতিটি ম্যাচ অভ্যন্তরীণ ফাংশনের ফলাফল দ্বারা প্রতিস্থাপিত হয়, যা দুটি আর্গুমেন্ট ব্যবহার করে: সমান চিহ্নের চালানো (পরিবর্তনশীল d) এবং সংখ্যা (পরিবর্তনশীল c)। ফাংশনটি সংখ্যার দ্বারা বিভক্ত রাস্তার দৈর্ঘ্য ++ দিয়ে প্রেরণ করে returns

ফলস্বরূপ স্ট্রিং এর পরে মূল্যায়ন করা হয় এবং প্রথম ইনপুটটির সাথে তুলনা করা হয়।

স্নিপেট স্ট্যাক করুন

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"}। লক্ষ্য করুন যে প্রতিটি রানের মধ্যে ""পর পরের সংখ্যার তুলনায় একের পর এক এর সংখ্যা কম one=

//.{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

এমএটিএল , 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 হয়, যদি সম্ভবত গতি হয় না।

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সঙ্গে সব সমান চিহ্ন শেষ থেকে সরানো ব্যবহার %% পরামিতি সম্প্রসারণ এবং +()সম্প্রসারিত globbing অপারেটর।

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' এর স্ট্যাক খালি রয়েছে, তবে এটি এখনও সঠিক সংখ্যাটি মুদ্রণ করে কারণ আমরা যাইহোক শূন্যে যোগ করব)।

প্রকৃত মান আমরা বিভাজক করছি হিসাবে: ${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 স্পষ্টভাবে গতিতে থাকলে 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
সূত্র

আপনার প্রথম কোড গল্ফ অভিনন্দন! সুন্দরভাবে সম্পন্ন!

— programmer5000

1

পিএইচপি 5 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

— ড্যারেন এইচ
সূত্র

1

চমৎকার প্রথম জমা!

— programmer5000

লুপটিতে অ্যাক্সেস করার আগে আমার $ z ঘোষণা করার দরকার নেই তা বুঝতে পেরে 5 টি অক্ষর কেটে দিন

— ড্যারেন এইচ

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

আমি এখনও এফ # তে নতুন, তাই আমি যদি অদ্ভুত বা বোকা কিছু করি তবে আমাকে জানান।

— রিক
সূত্র

1

সি # পদ্ধতি ( 137 122 বাইট)

প্রয়োজন using System.Linq19 বাইট, 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

— রিক
সূত্র

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

এটি অনলাইন চেষ্টা করুন!

রিটার্নস TRUEunambiguously, মান দ্রুত গাড়ী চালানোর জন্য FALSEসম্ভবত unspeedy বেশী জন্য।

— : Giuseppe
সূত্র

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
সূত্র

আমি কি গতির সীমা ছাড়িয়ে গেছি?

ইউনিট

রাস্তাটি

উদাহরণ এবং গণনা

নোট:

05 এ বি 1 ই , 24 22 বাইট

পাইথন 2 , 71 বাইট

পাইথন 3 , 79 বাইট

জাভাস্ক্রিপ্ট (ES6), 63 বাইট

ব্যবহার

ব্যাখ্যা

স্নিপেট স্ট্যাক করুন

জিএনইউ সি, 128 বাইট

পার্ল 5 , 43 বাইট

গণিত, 98 বাইট

জেলি , 27 বাইট

কিভাবে?

পাইথন 3, 90 বাইট

এমএটিএল , 31 30 বাইট

উদাহরণ সহ ব্যাখ্যা

এপিএল, 41 বাইট

টিআই-বেসিক, 168 165 বাইট

বাশ, 151 বাইট

ব্যাখ্যা

পাইথন 3.6, 111 বাইট

পিএইচপি 5 207 202 বাইট

ডায়ালগ এপিএল, 27 বাইট

এফ # (165 বাইট)

সি # পদ্ধতি ( 137 122 বাইট)

আর , 100 বাইট

পাওয়ারশেল , 71 বাইট