पृष्ठभूमि

एक आम पहेली है जो कुछ इस तरह से होती है:

एक घोंघा 30 फुट के कुएं के नीचे है। हर दिन घोंघा 3 फीट ऊपर चढ़ने में सक्षम है। रात में जब वे सोते हैं, तो वे 2 फीट नीचे स्लाइड करते हैं। घोंघे को कुएं से बाहर आने में कितने दिन लगते हैं?

सहज उत्तर है

30 दिन, क्योंकि घोंघा शीर्ष तक पहुंचने के लिए 30 दिनों के लिए प्रति दिन 1 फुट पर चढ़ता है,

लेकिन वास्तव में इसका जवाब है

28 दिन, क्योंकि एक बार घोंघा हवा में 27 फीट (27 दिनों के बाद) होता है, वे बस शेष 3 फीट 28 वें दिन शीर्ष पर चढ़ेंगे।

चुनौती

यह चुनौती इस पहेली को सामान्य करती है। इनपुट के रूप में तीन सकारात्मक पूर्णांकों को देखते हुए, कुल ऊंचाई, चढ़ने की ऊंचाई और गिरावट की ऊंचाई का प्रतिनिधित्व करते हुए, कुएं से बाहर निकलने में लगने वाले दिनों की संख्या वापस कर देंगे।

यदि घोंघा कुएं से बाहर नहीं निकल सकता है, तो आप 0 वापस कर सकते हैं, एक मिथ्या मान लौटा सकते हैं या एक अपवाद फेंक सकते हैं। आप ऐसा कोड भी लिख सकते हैं जो किसी समाधान के मौजूद होने पर ही रुकेगा।

यदि आप चाहें, तो आप गिरावट को एक नकारात्मक पूर्णांक के रूप में ले सकते हैं।

परीक्षण के मामलों

(३०, ३, २) -> २ 2
(84, 17, 15) -> 35
(9 ९, १५, ९) -> १२
(२ ९, १ 4, ४) -> २
(१३, १ 8, 8) -> १
(५, ५, १०) -> १
(7, 7, 7) -> १
(६ ९, ३, -) -> कोई नहीं
(81, 14, 14) -> कोई नहीं

स्कोरिंग

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है।

— musicman523
स्रोत

ग्रे आइल , संख्यात्मक I / O के लिए 1206 बाइट्स, I / O के लिए 149 बाइट्स

मजे के लिए। पहले कार्यक्रम की संरचना:

451 बाइट्स, संख्या को डॉट्स में परिवर्तित करना
121 बाइट्स, कोर फ़ंक्शन (एक अलग संस्करण नीचे लिखा गया है)
634 बाइट्स, डॉट्स को संख्या में परिवर्तित करना

संख्यात्मक इनपुट और आउटपुट लें। इनपुट है A, B, Cक्रमशः। अन्य (निकट) O(1)उत्तर की तुलना में , कोड की जटिलता है O(n)। लेकिन बड़ी संख्या के लिए, यह आपकी मेमोरी को खा सकता है।

यदि कोई समाधान नहीं मिला है तो लटकाएं।

INPUT p
POP Z r .!
f
POP Z o .
q
POP Z p [p]
GOTO [Z]
0
POP Z n .
GOTO w
1
POP Z n ..
GOTO w
2
POP Z n ...
GOTO w
3
POP Z n ....
GOTO w
4
POP Z n .....
GOTO w
5
POP Z n ......
GOTO w
6
POP Z n .......
GOTO w
7
POP Z n ........
GOTO w
8
POP Z n .........
GOTO w
9
POP Z n ..........
GOTO w
w
POP Z o .[o][o][o][o][o][o][o][o][o][o][n]
GOTO [r] [p] 
GOTO q
!
POP Z A .[o]
INPUT p
POP Z r .@
GOTO f
@
POP Z B .[o]
INPUT p
POP Z r .#
GOTO f
#
POP Z C .[o]
POP H N .[B]
U
POP Z A [A]
POP Z B [B]
GOTO D [A] 
GOTO $ [B] 
GOTO U
$
POP Z A .[A][C]
POP Z H ..[H]
POP Z B .[N]
GOTO U
D
POP Z r .
POP Z M .
POP Z N ...........
POP Z z .[N]
POP Z V .[H]
+
GOTO l[V] [H] 
POP Z H [H]
POP Z z [z]
GOTO ( [z] 
GOTO +
(
GOTO ) [H] 
POP Z z .[N]
POP Z M ..[M]
POP Z V .[H]
GOTO +
)
POP Z r .0[r]
POP Z M ..[M]
POP Z H .[M]
POP Z M .
POP Z V .[H]
POP Z z .[N]
GOTO +
l
POP Z r .0[r]
GOTO -
l.
POP Z r .1[r]
GOTO -
l..
POP Z r .2[r]
GOTO -
l...
POP Z r .3[r]
GOTO -
l....
POP Z r .4[r]
GOTO -
l.....
POP Z r .5[r]
GOTO -
l......
POP Z r .6[r]
GOTO -
l.......
POP Z r .7[r]
GOTO -
l........
POP Z r .8[r]
GOTO -
l.........
POP Z r .9[r]
GOTO -
-
GOTO / [M] 
POP Z H .[M]
POP Z M .
POP Z V .[H]
POP Z z .[N]
GOTO +
/
OUTPUT [r]

f(शायद) पुनरावर्ती फ़ंक्शन को पूर्णांक को डॉट्स में बदलने के लिए है। तर्क में [p]और उत्पादन में सहेजा गया है [o]।

Uएक फंक्शन टेस्टिंग है S1>=S2, जिसमें B, Aबचत A-Bकरते समय पैरामीटर को स्टोर किया जाता है A।

कोड से शुरू होने वाला कोड Dएक स्टब परिवर्तित संख्या में होता है।

अंतर्निहित सिद्धांत मेरे सी उत्तर (असंभव समाधान के लिए मिथ्या आउटपुट को बंद करने) के साथ समान है।

स्टैंडअलोन संस्करण, 149 156 157 167 170 230 बाइट्स, केवल यूरी I / O का समर्थन करते हैं

इनपुट के लिए डॉट्स होना चाहिए, उदाहरण के ..........लिए 10।

INPUT A
INPUT B
INPUT C
POP N H .
GOTO U
$
POP N A .[A][C]
POP Z H ..[H]
U
POP Z A [A]
POP Z N ..[N]
GOTO D [A] 
GOTO $ .[B] [N]
GOTO U
D
OUTPUT .[H]

Uगणना करता है A=A-B, और Dजब करने के लिए कूदता है A<=0। अन्यथा कॉल और कॉल करने के लिए $असाइन करता A+Cहै ।AU

यदि कोई समाधान नहीं मिला है तो लटकाएं।

ट्रिक्स: खाली स्ट्रिंग की व्याख्या करने के लिए "कंपाइलर" की क्षमता का दुरुपयोग करें। आप GOTOबिना शर्त कूदने के लिए बयान में शर्तों को चीर सकते हैं और उसी चाल के लिए काम करते हैं POP।

टिप्पणी: मैं इसे 3 बाइट्स से अधिक गोल्फ कर सकता हूं, लेकिन ऐसा करने से मेरा और व्हीटविग्र्ड का उत्तर बिल्कुल एक ही तर्क होगा। परिणाम शायद सबसे छोटा ग्रेसेल समाधान है और मैं इसे साबित करने की कोशिश कर रहा हूं।

— कीउ गण
स्रोत

आपने इसे पहले बनाया

— гвгений Новиков

अरे मैंने सोचा था कि मैं आपको बता दूंगा कि मैंने आपको फिर से छोटा बना दिया है। इसका केवल एक बाइट छोटा है और यह आपके नवीनतम गोल्फ से कुछ प्रेरणा लेता है।

— गेहूं जादूगर

@WheatWizard मैं अपने पुराने जवाब के आधार पर एक 155-बाइट समाधान है। लेकिन स्पोर्ट्समैनशिप के लिए, मैं इसे अपने जवाब के रूप में नहीं देखूंगा।

— कीउ गान

@KeyuGan नहीं, आगे बढ़ो। मैं इस खेल के बारे में अपने सभी प्रतिनिधि के बारे में परवाह नहीं है। मुझे पीट कर खुशी हो रही है। अगर मेरा कोड गोल्फ हो सकता है तो उसे न देखने के लिए मेरी गलती है। :)

— गेहूं जादूगर

@HeatWizard मुझे न तो। मुझे यकीन है कि यह पीपीसीजी पर अब तक का सबसे अच्छा समय है।

— कीउ गण

20

नोट: बाइट गिनती टिप्पणियों में मार्टिन एंडर द्वारा पूछताछ की जा रही है। ऐसा लगता है कि सी # उत्तरों में नामित, पुनरावर्ती लंबोदर अभिव्यक्तियों के साथ क्या करना है, इसके बारे में कोई स्पष्ट सहमति नहीं है। इसलिए मैंने इसके बारे में मेटा में एक प्रश्न पूछा है।

सी # (.NET कोर) , 32 31 बाइट्स

f=(a,b,c)=>a>b?1+f(a-b+c,b,c):1

इसे ऑनलाइन आज़माएं!

एक पुनरावर्ती दृष्टिकोण। यदि घोंघा बच नहीं सकता है, तो यह निम्नलिखित संदेश के साथ समाप्त होता है:Process is terminating due to StackOverflowException.

1 बाइट LiefdeWen के लिए धन्यवाद बचा लिया!

— चार्ली
स्रोत

1

आप निम्नलिखित भागों a<=bको बदलने a>bऔर स्वैप करने के लिए एक बाइट बाइट बचा सकते हैं

— LiefdeWen

3

सटीक समान कोड ES6 में काम करता हैf=(a,b,c)=>a<=b?1:1+f(a-b+c,b,c)

— तुषार

यदि आप fपुनरावर्ती कॉल के लिए उस नाम पर भरोसा कर रहे हैं, तो आपको उस कोड को एक नाम पर फ़ंक्शन असाइन करना होगा ।

— मार्टिन एंडर

4

मैं C # में गोल्फ नहीं करता हूं, इसलिए मुझे पूरी तरह से यकीन नहीं है कि सर्वसम्मति क्या है, लेकिन मुझे यह उम्मीद है fकि अगर यह नाम है, तो एक घोषणा और अर्धविराम के साथ पूर्ण विवरण की आवश्यकता होगी । पहली चीज़ जो मुझे मिली वह यह है लेकिन यहाँ कोई स्पष्ट सहमति नहीं है।

— मार्टिन एंडर

2

@MartinEnder मैं आमतौर पर सिर्फ कार्लोस के रूप में यहां किया जाता है, क्योंकि घोषणा केवल f=...मैं अनिश्चित हूं कि क्या हमें अंत में अर्ध-उपनिवेश जोड़ना चाहिए या नहीं।

— द लीथेलकोडर

13

ग्रे SNAIL, 219 206 169 167 159 156 146 बाइट्स (एक्री IO)

INPUT a
INPUT u
INPUT d
POP U c 
GOTO 1
3
POP f a [a][d]
POP U c ..[c]
1
GOTO 2 [a] 
GOTO 3 [U] [u]
POP f U ..[U]
POP f a [a]
GOTO 1
2
OUTPUT [c].

मुझे लगता है कि मैं इसे थोड़ा नीचे कर सकता हूं।

— गेहूं का जादूगर
स्रोत

बधाई हो!

— कीउ गण

11

जावास्क्रिप्ट (ईएस 6), 31 28 27 बाइट्स

@Annauld की बदौलत कुछ बाइट्स बचाए

मुझे एहसास नहीं था कि हम एक अपवाद के साथ असफल हो सकते हैं। यकीन है कि यह इष्टतम है:

u=>d=>g=h=>h>u?1+g(h-u+d):1

उदाहरण के लिए एक चर को असाइन करें f=, फिर कॉल करें f(climb)(fall)(height)। InternalError: too much recursionचढ़ना असंभव है तो फेंकता है।

जावास्क्रिप्ट (ईएस 6), 38 बाइट्स

f=(h,u,d=0)=>h>u?u>0?1+f(h-u,u-d):+f:1

एक पुनरावर्ती फ़ंक्शन जो दिनों की संख्या लौटाता है, या NaNकभी नहीं।

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f=(h,u,d=0)=>h>u?u>0?1+f(h-u,u-d):+f:1;

[
  [30,  3,  2],
  [84, 17, 15],
  [79, 15,  9],
  [29, 17,  4],
  [13, 18,  8],
  [ 5,  5, 10],
  [ 7,  7,  7],
  [69,  3,  8],
  [81, 14, 14]
].map(x => console.log(x + '', '->', f.apply(null, x)))

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

2

यह स्पष्ट है: यदि घोंघा बहुत अधिक पुनरावृत्ति करता है , तो चढ़ाई असंभव है। :)

— तुषार

1

शायद 27 एक उलट करी वाक्यविन्यास के साथ? d=>u=>g=h=>h>u?1+g(h-u+d):1

— Arnauld

@Arnauld धन्यवाद, जो आश्चर्यजनक रूप से अच्छी तरह से काम करता है ...

— ETHproductions

मैं इसे भ्रमित कर रहा हूं बाइट काउंट- एक चर में जो फ़ंक्शन असाइन किया गया है टी शामिल है, अन्य नहीं?

— प्रदर्शित नाम

शीर्ष संस्करण में @Orangesandlemons, आपके पास g=बीच में है क्योंकि यह चर पुनरावर्ती कॉल के लिए आवश्यक मध्यवर्ती फ़ंक्शन को संग्रहीत करता है। लंबे समय तक उत्तर एक पुनरावर्ती कॉल करता है f, जो यह बताता है कि नाम को बाइट की गिनती में शामिल किया गया है।

— संगीतज्ञ ५२३

10

एक्सेल, 51 46 बाइट्स

-1 बाइट @ स्कारबी की बदौलत ।

-4 क्योंकि INT (x) = FLOOR (x, 1)

=IF(B1<A1,IF(C1<B1,-INT((B1-A1)/(B1-C1)-1)),1)

क्रमशः सेल A1, B1 और C1 से लिया गया इनपुट। FALSEअमान्य परिदृश्यों के लिए रिटर्न ।

— Wernisch
स्रोत

ceiling(x)हमेशा के बराबर -floor(-x)है, इसलिए मुझे लगता है कि आप की जगह 1 बाइट बचा सकता है CEILING((A1-B1)/(B1-C1)+1,1)के साथ -FLOOR((B1-A1)/(B1-C1)+1,1)।

— स्कारबी

7

सी (जीसीसी), 39 43 44 46 47 58 60 बाइट्स

केवल 32-बिट जीसीसी और सभी आशावादी बंद पर।

f(a,b,c){a=a>b?b>c?1+f(a-b+c,b,c):0:1;}

वापसी 0 जब समाधान असंभव है। मूल पुनरावर्ती समाधान का एक संशोधित संस्करण।

@ जोनाह जे समाधान और @CarlosAlejo सी # समाधान से प्रेरित है।

मैं बाद में विस्तारित संस्करण को अपडेट करूँगा (जब मैं अपना ग्रे घोंघा उत्तर समाप्त करूँगा)।

— कीउ गण
स्रोत

अच्छा है! क्या आप विश्लेषणात्मक (गैर-संपीड़ित) समाधान को शामिल कर सकते हैं?

— koita_pisw_sou

1

@koita_pisw_sou ज़रूर

— कीऊ गान

यह कुछ भी "वापस" नहीं करता है। आप किसी स्थानीय पैरामीटर को असाइन करते हैं, जिसका मान फ़ंक्शन वापस आने के बाद वाष्पित हो जाता है। घोंघा अनन्त अंग में अटका हुआ है।

— कोडी ग्रे

@ बॉडीग्रेअर यह जीसीसी में एक स्थिर लेकिन अपरिभाषित व्यवहार का उपयोग करता है। मैं आपको बाद में एक लिंक दिखा सकता हूं।

— कीउ गान

@CodyGray codegolf.stackexchange.com/questions/2203/tips-for-golfing-in-c Assign instead of return

— Keyu Gan

7

जावा (ओपनजेडके 8) , 35 बाइट्स

(a,b,c)->b<a?c<b?(a+~c)/(b-c)+1:0:1

इसे ऑनलाइन आज़माएं!

मैथ जीत!

क्रेडिट

केविन क्रूज़सेन के लिए धन्यवाद

— ओलिवियर ग्रेजायर
स्रोत

1

थोड़ा समय हो गया है, लेकिन है a-c-1→ a+~c।

— केविन क्रूज़सेन

1

धन्यवाद @KevinCruijssen यह कुछ समय हो गया है, लेकिन गोल्फ गोल्फ है, कोई फर्क नहीं पड़ता जब यह होता है :-)

— ओलिवियर ग्राईगोइरे

मेरे विचार से भी। कुछ मौकों पर मैंने अपने मूल बाइट्स को आधा कर दिया, जब मैंने अपने पहले उत्तरों में से कुछ को देखा। ;)

— केविन क्रूज़सेन

5

पायथन 2 , 37 बाइट्स

f=lambda x,y,z:x-y<1or 1+f(x-y+z,y,z)

इसे ऑनलाइन आज़माएं!

अंत में मेरे मानक गणना के नीचे मेरा पुनरावर्ती संस्करण मिला (मैं इसे कॉल करने से पहले एक जोड़ने के बजाय अपने फ़ंक्शन के लिए एक गणना कर रहा था)।

पायथन 2 , 4346 बाइट्स

#43 bytes
lambda x,y,z:y/x>0 or[1-(x-y)/(z-y),0][z/y]
#46 bytes
lambda x,y,z:y/x and 1or[1-(x-y)/(z-y),0][z/y]

इसे ऑनलाइन आज़माएं!

"__> 0" के लिए "__ और 1" ट्रेडिंग करके 3 बाइट्स शेव किए।

बूलियन प्रवंचना का प्रयोग, अनिवार्य रूप से निष्पादित करता है:

if floor(y/x) > 0:
    return True # == 1
elif floor(z/y) == 1:
    return 0
elif floor(z/y) == 0:
    return 1-floor((x-y)/(z-y))
    # Python 2 implicitly treats integer division as floor division
    # equivalent: 1 + math.ceil((y-x)/(z-y))
    # because: -floor(-x) == ceil(x)

— कॉटी जॉनथन सक्समैन
स्रोत

2

आपको f=अपने कोड (पहला समाधान) के सामने रखना होगा , और आपकी बाइट गिनती 37 हो जाएगी, क्योंकि यह पुनरावर्ती है, इसलिए आप इसे गुमनाम नहीं छोड़ सकते। f=एक मेमने के लिए केवल तभी गिराया जा सकता है जब वह पुनरावर्ती न हो।

— मिस्टर एक्सकोडर

ध्यान दिया और संबोधित किया। मुझे बताने के लिए धन्यवाद।

— कोटी जॉनाथन सक्समैन

4

आर, 43 बाइट्स

अन्य उत्तरों से उधार लेना:

g=function(a,b,c)`if`(b<a,1+g(a-b+c,b,c),1)

यदि कोई समाधान नहीं होता है तो त्रुटि देता है।

— r2evans
स्रोत

अच्छा जवाब। PPCG में आपका स्वागत है!

— संगीतकार ५२३

3

जे, 25 बाइट्स

पहला अच्छा समाधान, जो एक धोखा है, क्योंकि यह मानता है कि "एक सकारात्मक पूर्णांक परिणाम के अलावा कुछ भी नहीं" बराबर "कोई नहीं":

>.>:%/2-/\

व्याख्या

2-/\हमारे 3 आइटम इनपुट में लंबाई 2 की विंडो का उपयोग करें, प्रत्येक के बीच एक माइनस साइन रखें, जो इनपुट के लिए 30 3 2, जैसे, रिटर्न27 1
%/ सूची के प्रत्येक तत्व के बीच एक विभाजन चिह्न रखें, हमारे मामले में सूची में केवल दो आइटम हैं, इसलिए इसका अर्थ है "27 को 1 से विभाजित करें"
>: 1 से वेतन वृद्धि
>. छत ले लो

आधिकारिक समाधान

यहां आधिकारिक समाधान है जो नकारात्मक और अनंत को 0 में परिवर्तित करता है, जो भाग मैं एक संतोषजनक समाधान खोजने में सक्षम नहीं था:

0:`[@.(>&0*<&_)>.>:%/2-/\

TIO

— जोनाह
स्रोत

If the snail cannot climb out of the well, you may return 0, return a falsy value, or throw an exception.परीक्षण के मामलों को लिखने के उद्देश्य से, मैंने केवल Noneयह संकेत देने के लिए चुना कि कोई जवाब नहीं था। क्या आप एक स्पष्टीकरण और इसे ऑनलाइन लिंक आज़माएं पर भी विचार करेंगे?

— संगीतज्ञ ५२३

@ musicman523 तय किया और किया।

— योना

3

पर्ल 5 , 37 बाइट्स

के लिए 35 बाइट्स कोड +2 -pa।

$i-=$F[2]while++$\,($i+=$F[1])<$_}{

इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स
स्रोत

3

PHP> = 7.1, 60 बाइट्स

प्रिंट 0 किसी भी बचने के लिए

[,$h,$u,$d]=$argv;echo$h>$u?$u>$d?ceil(($h-$d)/($u-$d)):0:1;

PHP सैंडबॉक्स ऑनलाइन

PHP> = 7.1, 67 बाइट्स

कोई बचने के लिए कुछ भी नहीं छापता है

for([,$h,$u,$d]=$argv;($u>$d?:$h<=$u)&&0<$h+$t*$d-$u*++$t;);echo$t;

PHP सैंडबॉक्स ऑनलाइन

— जार्ग हुल्सरमन
स्रोत

2

गणितज्ञ, 47 40 39 बाइट्स

If[#==#2,1,⌈(#-#3)/(#2-#3)⌉~Max~0]&

-7 बाइट @KeyuGan से

— J42161217
स्रोत

आपको इनपुट से निपटने की आवश्यकता है 69, 3, 8और ⌈जहां तक मुझे लगता है कि 3 बाइट्स के रूप में गिना जाता है।

— कीउ गान

सब ठीक हो गया! इसे अभी

— आज़माएँ

आप बयान Maxको बदलने के लिए उपयोग कर सकते हैं If। If[#<=#2,1,Max[⌈(#-#3)/(#2-#3)⌉,0]]&

— कीउ गान

2

रूबी , 49 47 बाइट्स

->h,a,b{h-a<1?1:(1.0*(h-a)/[a-b,0].max+1).ceil}

यदि घोंघा बाहर नहीं चढ़ सकता तो अपवाद फेंकता है

इसे ऑनलाइन आज़माएं!

— एलेक्स
स्रोत

1

@ जोना ने इसे तय किया

— एलेक्स

खरीद के पीछे क्या तर्क है? h-a<1?1:(1.0*(h-a)/[a-b,0].max+1).ceilपरीक्षण मामलों को पास करता है, और 9 बाइट्स बचाता है।

— गैलन

2

बैच, 66 बाइट्स

@set/an=%4+1,a=%1-%2+%3
@if %1 gtr %2 %0 %a% %2 %3 %n%
@echo %n%

दूसरा आखिरी टेस्ट केस कुछ भी नहीं छापा, और आखिरी टेस्ट केस वास्तव में दुर्घटनाग्रस्त हो गया CMD.EXE...

— नील
स्रोत

2

05AB1E , 19 बाइट्स

0[¼²+D¹<›i¾q}³-D1‹#

स्पष्टीकरण:

0                   Initialise stack with 0
 [                  while(true)
  ¼                   increment the counter variable
   ²+                 add the second input to the top of the stack
     D¹<›i            if it is greater than or equal to the first input
          ¾             push the counter variable
           q            terminate the program
             }        end if
              ³-      subtract the third input from the top of the stack
                D     duplicate top of stack
                 1‹   if it is less than 1
                   #  break the loop

अमान्य मानों के लिए, यह 1. से कम किसी भी मान को वापस कर सकता है। हालाँकि, 05AB1E में, केवल 1 सत्य है, इसलिए यह इस आवश्यकता को पूरा करता है कि अमान्य मान के लिए उत्पादन गलत होना चाहिए।

इसे ऑनलाइन आज़माएं!

— Okx
स्रोत

2

PHP, 60 बाइट्स

[,$h,$v,$d]=$argv;echo$h>$v?$v>$d?ceil(($h-$d)/($v-$d)):N:1;

प्रिंट Nके लिए None। के साथ भागो -r।

— टाइटस
स्रोत

2

05AB1E , 12 बाइट्स

.×ηO<²›1k2÷>

इसे ऑनलाइन आज़माएं!

0असंभव है तो प्रिंट ।

इनपुट प्रारूप:

[climb, -fall]
height

— आउटग्रॉफर को एरिक करें
स्रोत

2

जाप , 12 बाइट्स

@UµV-W §W}aÄ

इसे ऑनलाइन टेस्ट करें!

undefinedसंभवतः कुछ समय के लिए अपने ब्राउज़र को फ्रीज़ करने के बाद आउटपुट कभी नहीं, इसलिए कृपया सावधान रहें।

मुझे यकीन नहीं है कि यह इष्टतम है। oWV-W lसभी पिछले तीन मामलों पर काम करता है ...

— ETHproductions
स्रोत

के साथ आया था इस आदानों का क्रम बदलकर 11 बाइट्स के लिए।

— झबरा

2

हास्केल , 30 29 बाइट्स

(b!c)a=1+sum[(b!c)$a+c-b|a>b]

इसे ऑनलाइन आज़माएं!

मौजूदा हास्केल उत्तर की तुलना में कम है। शायद कोई और मुझे हरा सकता है।

यह समस्या को हल करने के लिए एक पुनरावर्ती दृष्टिकोण का उपयोग करता है। प्रत्येक पुनरावृत्ति अनिवार्य रूप से घोंघा के लिए आंदोलन का दिन है। यदि अंत तक छोड़ा गया दूरी अभी भी आवश्यक दूरी से कम है, तो हम अपनी पुनरावृत्ति को समाप्त करते हैं।

— गेहूं का जादूगर
स्रोत

इन्फिक्स संकेतन के साथ 1 बाइट बचाएं (b#c)a=1+sum[(b#c)$a+c-b|a>b]:।

— लैकोनी

@ लिकोनी को नहीं पता था कि यह किया जा सकता है। पारितोषिक के लिए धन्यवाद।

— गेहूं जादूगर

आप b!cसूची की समझ में चारों ओर के परनों को छोड़ सकते हैं ।

— जर्गुल

2

QBIC , 31 23 बाइट्स

बस आवश्यकताओं में बदलाव देखा। यह संस्करण इस बात की जाँच नहीं करता है कि घोंघा कभी कुएँ के शीर्ष पर पहुँच जाएगा या नहीं।

≈:-:>0|q=q+1┘a=a-b+:]?q

नीचे दिए गए स्पष्टीकरण, मूल संस्करण के लिए जो यह जांचता है कि क्या कोई समाधान मौजूद है, इस कोड के सभी प्रासंगिक भागों को भी कवर करता है।

मूल, 31 बाइट उत्तर:

~:>:|≈:-a>0|q=q+1┘c=c-a+b]?q\?0

व्याख्या

~           IF
 :          cmd line arg 'a'  (the increment of our snail)
  >         is greater than
   :        cmd line arg 'b'  (the decrement, or daily drop)
    |       THEN
≈           WHILE
 :          cmd line arg 'c'  (the height of the well)
  -a        minus the increment (we count down the hieght-to-go)
    >0|     is greater than 0 (ie while we haven't reached the top yet)
q=q+1       Add a day to q (day counter, starts at 1)
┘           (syntactic linebreak)
c=c-a+b     Do the raise-and-drop on the height-to-go
]           WEND
?q          PRINT q (the number of days)
\?0         ELSE (incrementer <= decrementer) print 0 (no solution)

इसे ऑनलाइन आज़माएं! (ठीक है, वास्तव में नहीं: यह QBIC का एक अनुवाद है, जो उत्तर में QBasic कोड के लिए चलता है। यह (कुछ कमी) QBasic वातावरण है)

— steenbergh
स्रोत

2

एक्सेल VBA, 47 बाइट्स

अनाम VBE तत्काल विंडो फ़ंक्शन जो ऑब्जेक्ट आउटपुट [A1:C1]से रेंज से VBE तत्काल विंडो में इनपुट लेता हैActiveSheet

यह मुख्य रूप से एक्सेल फार्मूला आधारित समाधान किसी भी विशुद्ध रूप से VBA समाधान से छोटा प्रतीत होता है जिसे मैं :(

?[If(B1>C1,-Int((B1-A1)/(B1-C1)-1),Int(A1=B1))]

— टेलर स्कॉट
स्रोत

1

हास्केल, 47 55 बाइट्स (48 यदि आवश्यक हो तो)

f d c s|d<=c=1|c<s= -1|d>c||c<s=1+(f(d-c+s)c s)

टपल भिन्नता

f(d,c,s)|d<=c=1|c<s= -1|d>c||c<s=1+(f(d-c+s)c s)

व्याख्या

f d c s       function that does all the heavy lifting =)
              d - depth
              c - climb per day
              s - slide per night

 |d<=c=1             recursion terminator. 1 day of climbing 
 |c<s= -1            possibility check. top can't be reached
 |otherwise=1+(f(d-c+s)c s)  1 day plus the rest of the distance

— सर्गी मार्टीनेंको जूनियर
स्रोत

1

1. आप d>c||c<sबस के साथ बदल सकते हैं 0<1, जैसा कि आप पहले से ही स्पष्ट रूप से अपने स्पष्टीकरण में करते हैं, क्योंकि otherwiseसिर्फ एक पर्यायवाची है True। 2. आपके टुपल संस्करण में पुनरावर्ती कॉल अभी भी करी है। 3. आप दो बाइट्स को बचाने के (d#c)sबजाय अपने फ़ंक्शन को परिभाषित कर सकते हैं f d c s।

— लकोनी

1

तुम भी जरूरत c<=sके बजाय c<s।

— लकोनी

1

ओपी पैदावार 38 बाइट्स की अनुमति के 0बजाय पुन-1 : उपयोग और उपयोग करना : इसे ऑनलाइन आज़माएं!

— लैकोनी

1

क्या आप किसी भी बाइट को बचाने के लिए एक infix पहचानकर्ता का उपयोग कर सकते हैं?

— संगीतज्ञ ५२३

मैं, पता नहीं है अगर मैं संपादित anser पोस्ट करना चाहिए, क्योंकि यह @ Laikoni के जवाब esentialy है

— सेर्गेई Martynenko जूनियर

1

पायथन 3, 41 बाइट्स

f=lambda a,b,c:int(b>=a)or 1+f(a-b+c,b,c)

के लिए त्रुटि

आउटगोल्फ @veganaiZe

— एलिक्स आइजनहार्ट
स्रोत

1

PPCG में आपका स्वागत है! अच्छा पहला उत्तर :)

— संगीतकार ५२३

2

मैं बहुत अजगर पता नहीं है, लेकिन आप को बदल सकता है int(b>=a)के लिए 1-(b<a)2 बाइट्स को बचाने के लिए?

— ETHproductions

1

APL (Dyalog) , 13 बाइट्स

(⌈+÷⊢)/0⌈2-/⊢

इसे ऑनलाइन आज़माएं!

यदि घोंघे कुएं से बाहर नहीं निकल सकते हैं, तो विभाजन पर शून्य से त्रुटियां।

— TwiNight
स्रोत

1

सी # (.NET कोर) , 37 बाइट्स

(h,c,f)=>h>c?f<c?1+(h-f-1)/(c-f):0:1;

गैर-पुनरावर्ती लांबा। यहाँ पाया सूत्र का उपयोग करता है । 6 बाइट्स को छोटा किया जा सकता है यदि "कोई नकारात्मक परिणाम" विफलता को वापस करने का एक वैध तरीका है; वर्तमान में 0 बदले

— कामिल दकरी
स्रोत

थोड़ी देर हो गई, लेकिन h-f-1हो सकता है h+~f।

— केविन क्रूज़सेन

1

पायथन v2 और v3, 44 बाइट्स

f=lambda x,y,z:1+f(x-(y-z),y,z)if x>y else 1

^ किसी भी मामले के लिए अनंत पुनरावर्तन (त्रुटि)।

— veganaiZe
स्रोत

आप लंबोदर का उपयोग कर सकते हैं। इसके अलावा, यह मेरे (जावा) जवाब के समान लगता है इसलिए मुझे सूत्र में सुधार का सुझाव देने की अनुमति दें (x-z-1)//(y-z)+1:। मैं ज्यादा अजगर नहीं करता हूं, इसलिए मैं गलत हो सकता हूं ...

— ओलिवियर ग्राईगोइरे

आप f=बाइट काउंट से खत्म कर सकते हैं , इफ्स और इलसेस के आस-पास की कुछ जगहों को हटा सकते हैं और अजगर 2 पर जा सकते हैं जहाँ पूर्णांक विभाजन एक एकल है/

— musicman523

धन्यवाद @ musicman523 मैंने आपकी सभी सलाह लेना समाप्त कर दिया ।

— वेगानीज

1

मुझे एहसास हुआ कि मेरे "क्लीन" (कोई अनंत पुनरावर्तन) कोड में बहुत सारे कोने-केस के मुद्दे नहीं थे जब अन्य इनपुट (यानी 4, 3, 8) के साथ उपयोग किया जाता था। @ musicman523 मुझे लगता है कि मैं "सबूत" देखना शुरू कर रहा हूं जो आप बोलते हैं।

— शाकाहारी

1

एचपी -15 सी प्रोग्रामेबल कैलकुलेटर, 26 बाइट्स

कार्यक्रम चलाने से पहले तीन नंबर को स्टैक में लोड किया जाता है। गिरावट की ऊंचाई एक नकारात्मक संख्या के रूप में दर्ज की गई है। यदि घोंघा कुएं से बाहर नहीं निकल सकता है, तो परिणाम या तो एक नकारात्मक संख्या या त्रुटि # 0 (शून्य विभाजन त्रुटि) है।

हेक्स में ओप कोड:

C5 C1 B4 C5 FB 74 1A C4 FA B4 C5 FD C1 C1 A3 70 C6 F0 B4 FA EB F1 FA B2 0A F1

निर्देश के अर्थ:

x↔y 
ENTER
g R⬆
x↔y 
− 
g TEST x≤0 
GTO A
R⬇
+ 
g R⬆
x↔y 
÷ 
ENTER
ENTER
f FRAC
TEST x≠0 
EEX 
0 
g R⬆
+ 
g INT 
1 
+ 
g RTN 
f LBL A
1

आप इस HP-15C सिम्युलेटर के साथ कार्यक्रम की कोशिश कर सकते हैं ।

— रयान
स्रोत

यह कमाल का है! PPCG में आपका स्वागत है :)

— musicman523

1

आम लिस्प, 49 बाइट्स

(defun f(a b c)(if(> a b)(1+(f(+(- a b)c)b c))1))

इसे ऑनलाइन आज़माएं!

पुनरावर्ती कार्य, यदि कोई समाधान नहीं मिला तो अतिप्रवाह।

— रेंज़ो
स्रोत

1

पॉवरशेल , 95 94 बाइट्स

$g=$args[0]
$c=$args[1]
$f=$args[2]
$p=0
$d=0
1..$g|%{$d+=1;$p+=$c;if($p-ge$g){$d;exit}$p-=$f}

इसे ऑनलाइन आज़माएं!

— जड़
स्रोत

द स्नेल इन द वेल

पृष्ठभूमि

चुनौती

परीक्षण के मामलों

स्कोरिंग

ग्रे आइल , संख्यात्मक I / O के लिए 1206 बाइट्स, I / O के लिए 149 बाइट्स

स्टैंडअलोन संस्करण, 149 156 157 167 170 230 बाइट्स, केवल यूरी I / O का समर्थन करते हैं

सी # (.NET कोर) , 32 31 बाइट्स

ग्रे SNAIL, 219 206 169 167 159 156 146 बाइट्स (एक्री IO)

जावास्क्रिप्ट (ईएस 6), 31 28 27 बाइट्स

जावास्क्रिप्ट (ईएस 6), 38 बाइट्स

परीक्षण के मामलों

एक्सेल, 51 46 बाइट्स

सी (जीसीसी), 39 43 44 46 47 58 60 बाइट्स

जावा (ओपनजेडके 8) , 35 बाइट्स

क्रेडिट

पायथन 2 , 37 बाइट्स

पायथन 2 , 4346 बाइट्स

आर, 43 बाइट्स

जे, 25 बाइट्स

व्याख्या

आधिकारिक समाधान

पर्ल 5 , 37 बाइट्स

PHP> = 7.1, 60 बाइट्स

PHP> = 7.1, 67 बाइट्स

गणितज्ञ, 47 40 39 बाइट्स

रूबी , 49 47 बाइट्स

बैच, 66 बाइट्स

05AB1E , 19 बाइट्स

PHP, 60 बाइट्स

05AB1E , 12 बाइट्स

जाप , 12 बाइट्स

हास्केल , 30 29 बाइट्स

QBIC , 31 23 बाइट्स

व्याख्या

एक्सेल VBA, 47 बाइट्स

पायथन 3, 41 बाइट्स

APL (Dyalog) , 13 बाइट्स

सी # (.NET कोर) , 37 बाइट्स

पायथन v2 और v3, 44 बाइट्स

एचपी -15 सी प्रोग्रामेबल कैलकुलेटर, 26 बाइट्स

आम लिस्प, 49 बाइट्स

पॉवरशेल , 95 94 बाइट्स