दो कदम आगे और एक कदम पीछे

15

मान लीजिए कि मैं अपनी मंजिल से दस कदम दूर हूं। मैं पुरानी कहावत का पालन करते हुए चलता हूं, "दो कदम आगे और एक कदम पीछे"। मैं दो कदम आगे बढ़ाता हूं, एक पीछे, जब तक कि मैं अपने गंतव्य पर बिल्कुल नहीं खड़ा हूं। (इसमें मेरे गंतव्य पर कदम रखना और उसमें वापस आना शामिल हो सकता है)। कितने कदम चले?

बेशक, मैं 10 कदम दूर नहीं हो सकता। मैं 11 कदम दूर हो सकता हूं, या 100. मैं दस पेस माप सकता हूं, और समस्या को हल करने के लिए आगे-पीछे घूमता रह सकता हूं, या ... मैं कुछ कोड लिख सकता हूं!

  • इस क्रम में एन चरणों को प्राप्त करने के लिए कितने चरण लगते हैं, यह जानने के लिए एक कार्य लिखें: दो कदम आगे, एक कदम पीछे।
  • मान लें कि आपने चरण ० पर शुरू किया है। "दो कदम आगे" की गिनती दो चरणों के रूप में करें, एक पर नहीं।
  • मान लें कि सभी चरण एक समान लंबाई हैं।
  • जब आप उस स्थान पर पहुँचते हैं, तो पहले उठाए गए कदमों की संख्या वापस कर देनी चाहिए। (उदाहरण के लिए, 10 कदम दूर 26 कदम लगते हैं, लेकिन आप इसे फिर से 30 कदम पर मारेंगे)। हम 26 में रुचि रखते हैं।
  • अपनी पसंद की किसी भी भाषा का उपयोग करें।
  • इसे इनपुट के रूप में किसी भी सकारात्मक पूर्णांक को स्वीकार करना चाहिए। यह लक्ष्य चरण का प्रतिनिधित्व करता है।
  • सबसे छोटी संख्या बाइट्स जीतती है।

उदाहरण:

मैं 5 कदम दूर जाना चाहता हूं:

| | | | | | <- I'm at step 0, not yet on the grid.
| |X| | | | <- I take two steps forward, I'm on step 2: the count is 2
|X| | | | | <- I take one step back, I'm on step 1: the count is 3
| | |X| | | <- I take two steps forward, I'm on step 3: the count is 5
| |X| | | | <- I take one step back, I'm on step 2 again: the count is 6
| | | |X| | <- I take two steps forward, I'm on step 4: the count is 8
| | |X| | | <- I take one step back, I'm on step 3 again: the count is 9
| | | | |X| <- I take two steps forward, I'm on step 5: the count is 11

इस मामले में, फ़ंक्शन का परिणाम 11 होगा।

उदाहरण के परिणाम:

1      =>  3
5      =>  11
9      =>  23
10     =>  26
11     =>  29
100    =>  296
1000   =>  2996
10000  =>  29996
100000 =>  299996

मज़े करो, गोल्फरों!

code-golf  math  arithmetic 
— AJFaraday
स्रोत
7
हम्म ... यह बहुत परिचित लगता है।
— शैगी
3
— रॉड
@ राड हुर्रे! मैं इसके साथ भाग गया! ;)
— एजेफाराडे
हां, यह उसी तरह दिखता है जैसे मैं @Rod के बारे में सोच रहा था।
— शैगी
@ शैगी रॉड ने अपनी टिप्पणी को थोड़ा बदल दिया। पहले वाले ने नोट किया कि घोंघे / कुएं का सवाल पुनरावृत्तियों की संख्या पूछ रहा है, लेकिन यह दूरी तय करने के लिए कह रहा है।
— AJFaraday

जवाबों:

5

ओएसिस , 5 4 बाइट्स

1 बाइट ने @ अदनान को धन्यवाद दिया

3+23

से भ्रमित नहीं होना है 23+3

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

कैसे?

      implicitly push a(n-1)
3     push 3
 +    sum and implicitly print
  2   a(2) = 2
   3  a(1) = 3
— Uriel
स्रोत
1
आप बाहर छोड़ सकते हैं b।
— अदनान
मुझे लगता है कि आपका मतलब 3 से गुणा करना है, इसे जोड़ना नहीं है।
— १ E:१17 पर आउटगोल्फ
@EriktheOutgolfer कार्यक्रम एक (n-1) +3 के रूप में (n) गणना करता है ।
— डेनिस
9

पॉलीग्लॉट: जावा 8 / जावास्क्रिप्ट / सी # .NET, 16 14 12 बाइट्स

n->3*n-1%n*4

इसे ऑनलाइन आज़माएं (Java 8)।

n=>3*n-1%n*4

इसे ऑनलाइन (जावास्क्रिप्ट) आज़माएं।
इसे ऑनलाइन आज़माएं (C # .NET) ।

पोर्ट ऑफ @ लियोन पायथन 2 का उत्तर है , इसलिए उसका उत्तर सुनिश्चित करें।

पुराना उत्तर:

बहुभुज: जावा 8 / जावास्क्रिप्ट / सी # .NET, 16 14 बाइट्स

n->n<2?3:n*3-4

इसे ऑनलाइन आज़माएं (Java 8)।

n=>n<2?3:n*3-4

इसे ऑनलाइन (जावास्क्रिप्ट) आज़माएं।
इसे ऑनलाइन आज़माएं (C # .NET) ।

स्पष्टीकरण:

n->       // Method with integer as both parameter and return-type
  n<2?    //  If the input is 1:
   3      //   Return 3
  :       //  Else:
   n*3-4  //   Return the input multiplied by 3, and subtract 4
— केविन क्रूज़सेन
स्रोत
यदि आप एक वसा तीर का उपयोग करते हैं, तो जावास्क्रिप्ट पॉलीग्लॉट।
— झबरा
@Shaggy जोड़ा गया, साथ ही C # .NET :) हालांकि n=>(--n*3||4)-1जावास्क्रिप्ट (14 बाइट्स) में भी संभव है।
— केविन क्रूज़सेन
7

आर , 20 बाइट्स

N=scan();3*N-4*(N>1)

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

जब तक मैंने अपना कम सुरुचिपूर्ण समाधान लागू नहीं किया, तब तक पैटर्न पर ध्यान नहीं दिया।

— ग्यूसेप
स्रोत
3
10k BTW पर बधाई!
— लुइस मेंडो
4
@LuisMendo धन्यवाद! मुझे लगता है कि साइट पर मेरी एक साल की सालगिरह कुछ दिन पहले थी, इसलिए यह मेरे लिए एक अच्छा सप्ताह है, पीपीसीजी-वार।
— Giuseppe
3
@Giuseppe मुझे पता है कि भावना: पिछले हफ्ते 20k, साथ ही 2 साल की सालगिरह। :)
— केविन क्रूज़सेन
4

MATL , 7 बाइट्स

3*n-4*(n>1)सूत्र का उपयोग करता है। इनपुट को 3 से गुणा करें ( 3*), इनपुट को फिर से पुश करें ( G) और इसे घटाएँ ( q)। यदि परिणाम शून्य नहीं है ( ?) तो परिणाम से 4 घटाएं ( 4-)।

3*Gq?4-

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

— डेविड
स्रोत
6 बाइट्स डेनिस 'जेली जवाब2-|EG+
— Giuseppe
3

मशीनकोड x86_64, 34 32 24 बाइट्स पर

8d47fe9931d029d08d0447c3

iपूर्णांक आउटपुट के लिए ध्वज की आवश्यकता होती है ; इनपुट को कोड में मैन्युअल रूप से जोड़ने के माध्यम से लिया जाता है।

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

मैं 24-बाइट मशीनकोड प्रोग्राम को खोजने के लिए इन 4 अलग-अलग सी फ़ंक्शन के माध्यम से गया:

  • n+2*abs(n-2)= 8d47fe9931d029d08d0447c3(24 बाइट्स)
  • 3*n-4*!!~-n= 8d047f31d2ffcf0f95c2c1e20229d0c3(32 बाइट्स)
  • n*3-4*(n>1)= 31d283ff028d047f0f9dc2c1e20229d0c3(34 बाइट्स)
  • n<2?3:n*3-4= 83ff01b8030000007e068d047f83e804c3(34 बाइट्स)
— एमडी एक्सएफ
स्रोत
तो वास्तव में यह भाषा क्या है?
— qwr
@qwr एक साधारण विवरण के लिए भंडार में README की जाँच करें।
— एमडी एक्सएफ
2

4 , 54 बाइट्स

3.6010160303604047002020003100000180010202046000095024

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

यदि आप इनपुट विधि पर सवाल उठाते हैं, तो कृपया पहले संख्यात्मक इनपुट पर जाएँ और आउटपुट कोड मेटा पोस्ट के रूप में दिया जा सकता है ।

— Uriel
स्रोत
इसे क्यों ठुकरा दिया गया?
— ऊरीएल
क्योंकि उत्तर एक चौथाई प्रतीत होता है, जो एक मान्य परिणाम नहीं है। जहाँ तक मैं बता सकता हूँ, यह समस्या को हल नहीं करता है।
— एजेफराडे
@AJFaraday यह बाइट इनपुट और आउटपुट का उपयोग करता है, जो मेटा सर्वसम्मति द्वारा मान्य है। इनपुट सेक्शन के अंदर का विवरण देखें
— यूरिल
परिणाम की व्याख्या करने के तरीके पर कोई संसाधन? या इनपुट?
— एजेफराडे
1
@AJFaraday परिणाम का चार कोड उत्तर है। मैंने प्रासंगिक मेटा पोस्ट को शामिल करने के लिए प्रश्न को संपादित किया है। 4केवल चार इनपुट है।
— यूरिल
2

जाप, 7 बाइट्स

लिन के पायथन समाधान का एक बंदरगाह।

*3É%U*4

कोशिश करो

विकल्प

यह बंद फार्मूला समाधानों के लिए एक मजेदार विकल्प था, दुर्भाग्य से, अब एक बाइट:

_+3}gN³²

कोशिश करो

— झबरा
स्रोत
2

65816 मशीन कोड, 22 बाइट्स

मैं इस 65C02 मशीन कोड को 3 बाइट्स के लिए आसानी से बना सकता था, लेकिन ऐसा नहीं किया, क्योंकि 65C02 पर रजिस्टर आकार 16-बिट के बजाय 8-बिट है। यह काम करेगा, लेकिन यह उबाऊ है क्योंकि आप केवल बहुत कम संख्या का उपयोग कर सकते हैं ;-)

xxd डंप:

00000000: 7aa9 0000 aa89 0100 d004 8888 e824 c8e8  z............$..
00000010: 1ac0 0000 d0ef                           ......

disassembly / कोड स्पष्टीकरण:

; target is on the stack
  ply              7A                  ; pull target from stack
  lda #$0000       A9 00 00            ; set loop counter to 0
  tax              AA                  ; set step counter to 0
loop:
  bit #$0001       89 01 00            ; sets Z if loop counter is even
  bne odd          D0 04               ; if Z is not set, jump to 'odd'
  dey              88                  ; decrement target twice
  dey              88
  inx              E8                  ; increment step counter
  .byte $24        24                  ; BIT $xx opcode, effectively skips the next byte
odd:
  iny              C8                  ; increment target

  inx              E8                  ; increment step counter
  inc a            1A                  ; increment loop counter

  cpy #$0000       C0 00 00            ; sets zero flag, can be optimized maybe?
  bne loop         D0 EF               ; if Y is non-zero, loop

; result is in register X

65816-संगत एमुलेटर पर इसका परीक्षण करना:

परिक्षण

— 2xsaiko
स्रोत
1

शेल , 28 बाइट्स

F(){ bc<<<$1*3-$(($1>1))*4;}

टेस्ट:

F 1
3

F 2
2

F 3
5

F 4
8

F5
11

F 11
29

F 100
296

F 100000
299996

स्पष्टीकरण:

सूत्र है: 

if n == 1  ==> F(1) = 3
else F(n) = 3*n - 4

3 चरणों के क्रम के बाद "दो कदम आगे और एक कदम पीछे", हमारे पास अंकगणितीय श्रृंखला होगी:

 +2  2 => 2  ( or 6 )
 -1  1 => 3
 -----------
 +2  3 => 5  ( or 9 )
 -1  2 => 6
 -----------
 +2  4 => 8  ( or 12 )
 -1  3 => 9
 -----------
 +2  5 => 11 ( or 15 )
 -1  4 => 12
 -----------
 +2  6 => 14 ( or 18 )
 -1  5 => 15 
 -----------
 +2  7 => 17 ( or 21 )
 -1  6 => 18

न्यूनतम या पहले संयोग पर:

 1 => 3
 2 => 2
 3 => 5
 4 => 8
 5 => 11
 6 => 14

एक सूत्र में: 

F(n) = 3*n - 4(n>1)     with n>1 is 1 or 0 (if n==1)
— अली ISSA
स्रोत
कृपया वर्णन करें कि यह कौन सा शेल है
— qwr
Cygwin (CYGWIN_NT-10.0 2.3.1 (0.291 / 5/3) 2015-11-14 12:44 x86_64 Cygwin पर परीक्षण किया गया
— अली ISSA
क्या आप इसे सीधे bc में लिख सकते हैं?
— qwr
मैं बीसी से परिचित नहीं हूं, लेकिन चूंकि फ़ंक्शन का तर्क ($ 1) कई बार उपयोग किया जाता है और कुछ शेल-विशिष्ट सामान (अंकगणित विस्तार $((…))) किया जाता है, शायद नहीं।
— 2xsaiko
1
F(){bc<<<$1*3-$(($1>1))*4}हालांकि zsh में काम करता है और 2 बाइट्स निकालता है
— 2xsaiko
1

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

def a(x):
    if x!=1:
        return((3*x)-4)
    return(3)

यह ऑनलाइन की कोशिश करो!

— नाथन डिम्मर
स्रोत
अच्छा काम। आप "पाद" अनुभाग में भी कुछ कोड डालना चाह सकते हैं। इस तरह आप अपने गोल्फ एंट्री को
— पेड
@AJFaraday मेरे पद का पाद लेख या मेरे कोड का?
— नाथन डिमर
ऑनलाइन प्रयास करें; आप एक पाद लेख जोड़ सकते हैं जो आपके कोड के साथ चलता है, लेकिन बाइट की लंबाई की गणना नहीं करता है। फिर आउटपुट काम पर अपना कोड दिखाएगा।
— AJFaraday
— जो किंग
@JoKing क्या आप पायथन में लंबोदर कार्यों के लिए एक अच्छे गाइड के बारे में जानते हैं? मैं वास्तव में समझ में नहीं आता कि वाक्य रचना कैसे काम करती है।
— नाथन डिमर
1

ब्रेन-फ्लैक , 38 बाइट्स

({<([()()]{})>()(){(<((){})>)()}{}}{})

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

पहला उत्तर मैं आगे और पीछे कदम बढ़ाकर उत्तर की गणना करने के लिए देखता हूं।

({ while not at 0
  <([()()]{})>()() take two steps forward, counting 2 steps
  {(<((){})>)()}{} take one step back, if not at 0, and add 1 step
}{}) remove the 0 and push step sum
— MegaTom
स्रोत
1

डब्ल्यू d , 7 बाइट्स

♦óÖ╣░Θ$

व्याख्या

3*1a<4*-

मूल्यांकन करता है (a*3)-4*(a>1)।

एक और संभावित विकल्प

3*1am4*-

मूल्यांकन करता है (a*3)-4*(1%a)।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.