हम ऐसे ही काम करते हैं

Question

कई कारणों से पीट एक दिलचस्प प्रोग्रामिंग भाषा है। आज हम एक कारण पर ध्यान केंद्रित करेंगे: रोल कमांड। रोल कमांड मूल रूप से पोस्टस्क्रिप्ट से था और स्टैक में हेरफेर करने का एक शक्तिशाली तरीका है।

रोल कमांड स्टैक के शीर्ष दो तत्वों को पॉप करता है और उन्हें मापदंडों के रूप में उपयोग करता है। हम पहले मूल्य को पॉपप कहेंगे turnsऔर दूसरे को depth। गहराई n की ओर स्टैक का सबसे ऊपरी तत्व लगेगा, इसे स्टैक में nth तत्व बनाते हैं, और इसके ऊपर के प्रत्येक तत्व को ऊपर ले जाते हैं। यदि turns नकारात्मक है तो यह विपरीत दिशा में किया जाता है। अर्थात्, nth तत्व को शीर्ष पर ले जाया जाता है और अन्य तत्वों को नीचे ले जाया जाता है। ऐसा बार- abs(turns)बार होता है।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक स्टैक में होता है और एक रोल को निष्पादित करने के बाद उस स्टैक को वापस करता है।

नियम

• इनपुट और आउटपुट एक सूची में हो सकता है, सरणी, स्ट्रिंग एक सीमांकक के साथ, एक समय में एक तत्व में पारित, या किसी अन्य उचित प्रारूप में। आउटपुट इनपुट के समान प्रारूप में होना चाहिए।
• depth कभी भी नकारात्मक नहीं होगा और स्टैक की लंबाई से अधिक कभी नहीं होगा।
• इनपुट स्टैक में हमेशा कम से कम दो तत्व होंगे।
• यह कोड-गोल्फ है इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है। जैसे, मैं एक उत्तर स्वीकार नहीं करूंगा।
• मानक खामियों को मना किया जाता है।

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

in:  out:
2    
4    
1    3
2    4
3    1
4    2
5    5
6    6

in:  out:
-2   
3
1    2
2    3
3    1

in:  out:
-42
0
1    1
2    2
3    3
4    4
5    5

Comments

प्रत्येक भाषा में सबसे कम उत्तर जीतता है , यही नहीं [कोड-गोल्फ] कैसे काम करता है। सबसे छोटा जवाब जीत। अवधि।

— mbomb007

@ mbomb007 अहम इस बारे में क्या

— क्रिस्टोफर

मैं बहुत निराश था कि इसने किसी भी तरह से रिक रोलिंग को शामिल नहीं किया

— क्रिस्टोफर

@ mbomb007 मैं टैग विवरण में या मेटा पर त्वरित खोज में नहीं देख रहा हूं इसलिए मुझे नहीं लगता कि ऐसा है।

— मिक बुफर्देसी

@ mbomb007 अगर आप मुझे इसे बदलना चाहते हैं, तो कृपया "आप गलत हैं और मैं सही हूँ" कहने के अलावा कुछ और तर्क प्रदान करें। इसके लिए एक मिसाल है, जिसे आपने खारिज कर दिया था, और कहीं भी यह नहीं कहा गया है कि चुनौतियों के लिए ठीक एक विजेता की जरूरत है या एक उत्तर को स्वीकार किया जाना चाहिए।

— माइक बुफर्देसी

Answer 1

हास्केल , 64 62 बाइट्स

संपादित करें: -2 बाइट्स: @xnor ने कुछ ऐसा देखा जिसके बारे में मैंने गलत सोचा था।

rलेता है और Intएस की सूची देता है ।

r(t:d:l)|d<1=l|(x,y)<-d%l,(z,w)<-mod t d%x=w++z++y
(%)=splitAt

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

splitAt n llसूचकांक में एक सूची को विभाजित करता है n, modविभाजन के शेष की गणना ++करता है , सूचियों को एकत्र करता है।

Comments

मुझे लगता है कि आप (%)=splitAtइन्फिक्स को परिभाषित करके 2 बाइट्स काट सकते हैं ।

— xnor

@xnor ओह, मैंने किसी तरह अपने आप को आश्वस्त किया था कि वह काम नहीं करेगा

— senrjan जोहानसन

Answer 2

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

(t,d,...a)=>a.splice(t=(t%d+d)%d,d-t).concat(a)

संपादित करें: स्टैक तत्वों को अलग मापदंडों के रूप में ले कर @ बग्घी की बदौलत 2 बाइट्स सहेजे गए। स्पष्टीकरण:

• जब मोड़ कई गहराई का होता है, तो कुछ भी नहीं होता है। इसलिए पहला कदम टर्न मोडुलो डेप्थ की गणना करना है। जैसा कि जावास्क्रिप्ट केवल यह जानता है कि शेष की गणना कैसे करें, मुझे यह दो चरणों में करना होगा।
• 1शीर्ष तत्व की ओर जाने की बारी हैdepth । 2शीर्ष दो तत्वों, आदि को चालू करने की बारी है , हालांकि, आप इसे मोड़ और गहराई के बीच के तत्वों को सामने की ओर ले जाकर भी प्राप्त कर सकते हैं। spliceउन तत्वों को निकालता है और concatउन्हें शेष तत्वों के लिए प्रस्तुत करता है। (मैं एक सरणी समझ का उपयोग कर सकता था क्योंकि यह एक ही लंबाई है।)
• इसके विपरीत slice, दूसरे पैरामीटर spliceको हटाने के लिए तत्वों की संख्या है।

Comments

के (t%d+d)%dरूप में ही नहीं है t%d?

— ल्यूक

@Luke नहीं, %शेष है, इसलिए यह नकारात्मक होने पर नकारात्मक उत्तर देता tहै।

— नील

आप (t,d,...a)=>एक बार में एक तत्व में इनपुट को पारित करने के लिए नियमों को अनुमति देते हुए 2 बाइट बचा सकते हैं।

— झबरा

@ शुग्गी धन्यवाद, मैंने उस पर ध्यान नहीं दिया था।

— नील

Answer 3

सीजेएम, 31 बाइट्स

)\):N@\,0a|={NW*1$1$>)\+@@<\+}*

इनपुट और आउटपुट स्टैक पर ऐरे हैं, अंतिम तत्व स्टैक के शीर्ष का प्रतिनिधित्व करते हैं।

स्टैक ट्रेस:

                   e# Stack:                [6 5 4 3 2 1 4 2]
)                  e# Take out first value: [6 5 4 3 2 1 4] 2
\                  e# Swap:                 2 [6 5 4 3 2 1 4]
)                  e# Take out first value: 2 [6 5 4 3 2 1] 4
:N                 e# Store in N:           2 [6 5 4 3 2 1] 4; N=4
@                  e# Rotate:               [6 5 4 3 2 1] 4 2
\                  e# Swap:                 [6 5 4 3 2 1] 2 4
,                  e# Range:                [6 5 4 3 2 1] 2 [0 1 2 3]
0                  e# Push 0:               [6 5 4 3 2 1] 2 [0 1 2 3] 0
a                  e# Wrap in array:        [6 5 4 3 2 1] 2 [0 1 2 3] [0]
|                  e# Logical or:           [6 5 4 3 2 1] 2 [0 1 2 3]
                   e# (This will replace an empty array with [0] to handle a special case of n=0)
=                  e# Get array value:      [6 5 4 3 2 1] 2
{NW*1$1$>)\+@@<\+} e# Push block:           [6 5 4 3 2 1] 2 {NW*1$1$>)\+@@<\+}
*                  e# Preform n times:      [6 5 4 3 2 1]
  N                e# Push N:               [6 5 4 3 2 1] 4
  W*               e# Negate:               [6 5 4 3 2 1] -4
  1$               e# Copy element 1 back:  [6 5 4 3 2 1] -4 [6 5 4 3 2 1]
  1$               e# Copy element 1 back:  [6 5 4 3 2 1] -4 [6 5 4 3 2 1] -4
  >                e# Slice a[-4:]          [6 5 4 3 2 1] -4 [4 3 2 1]
  )                e# Take first value:     [6 5 4 3 2 1] -4 [4 3 2] 1
  \                e# Swap:                 [6 5 4 3 2 1] -4 1 [4 3 2]
  +                e# Append:               [6 5 4 3 2 1] -4 [1 4 3 2]
  @@               e# Rotate twice:         [1 4 3 2] [6 5 4 3 2 1] -4
  <                e# Slice a[:-4]:         [1 4 3 2] [6 5]
  \                e# Swap:                 [6 5] [1 4 3 2]
  +                e# Append:               [6 5 1 4 3 2]
e# Preform the block again:                 [6 5 2 1 4 3]

Answer 4

गणितज्ञ, ५hem ५० बाइट्स

संपादित करें: 8 बाइट बचाने के लिए मार्टिन एंडर का धन्यवाद।

Take[x={##3},#2]~RotateLeft~#~Join~Drop[x,#2]&@@#&

स्पष्टीकरण:

शुद्ध फ़ंक्शन जो एक सूची की उम्मीद करता है जहां सूची की शुरुआत स्टैक के शीर्ष का प्रतिनिधित्व करती है। हम सूची के तत्वों को शुद्ध फ़ंक्शन में पास करते हैं Take[x={##3},#2]~RotateLeft~#~Join~Drop[x,#2]&। xतीसरे तर्क के साथ शुरू होने वाले तत्वों के अनुक्रम पर सेट है। फिर, हम बाईं ओर के पहले #2(दूसरे तर्क) तत्वों को घुमाते हैंx# (पहले तर्क) बार , फिर Joinशेष तत्वx ।

यह बचाना होगा 3 बाइट्स अगर हमने स्टैक तत्वों को शुरू में एक सूची में होने के बजाय सीधे फ़ंक्शन के तर्क के रूप में पारित किया, लेकिन फिर इनपुट और आउटपुट प्रारूप मेल नहीं खाएंगे।

मूल समाधान:

#/.{t_,d_,x___}:>{x}~Take~d~RotateLeft~t~Join~Drop[{x},d]&

वहाँ वास्तव में infix कार्यों की इस श्रृंखला के बारे में संतोषजनक कुछ है। पहले तत्व t, दूसरे तत्व dऔर शेष तत्वों के xसाथ एक सूची को बाईं ओर के पहले dतत्वों को घुमाने और शेष तत्वों में शामिल होने के परिणामस्वरूप प्रतिस्थापित करता है ।{x}t{x}

Comments

अच्छा! आप ±एक प्रतिस्थापन नियम के एक-बाइट उपसर्ग फ़ंक्शन इनसेट का उपयोग करके 3 बाइट्स बचा सकते हैं , और दूसरा 1 बाइट TakeDropनिम्नानुसार शोषण करके : ±{t_,d_,x___}:=#~RotateLeft~t~Join~#2&@@{x}~TakeDrop~d

— ग्रेग मार्टिन

मैं बस ग्रेग के रूप में एक ही टिप्पणी करने जा रहा था, लेकिन आप वास्तव में भी छोटे जा सकते हैं। या तो एक अनाम वैरिएबल फ़ंक्शन करें (हालांकि यह थोड़ा डोडी है क्योंकि यह इनपुट लेता है ...&[1, 1, 3, 4]और वापसी करता है {3, 4}या मैन्युअल रूप Applyसे शुरुआत में एक साथ करता है: Take[x={##3},#2]~RotateLeft~#~Join~Drop[x,#2]&@@#&(बस स्पष्ट होना, मेरा पहला सुझाव छोड़ देता है @@#&)।

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

Answer 5

रूबी, 40 बाइट्स

x=->s{n,d,*s=s;s[0,d]=s[0,d].rotate n;s}

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

इनपुट को एक सूची के रूप में लेता है, एक सूची देता है। तथ्य यह है कि एक अंतर्निहित rotateमौजूद है जो सकारात्मक और नकारात्मक दोनों घुमावों को संभाल सकता है यह तुच्छ बनाता है।

Answer 6

पायथन, 141 98 87 74 बाइट्स

11 बाइट्स @Cole की बदौलत बच गईं

def f(s):*s,d,t=s;n=len(s)-d;return s*0**d or s[:n]+s[-t%d-d:]+s[n:-t%d-d]

एक सूची के रूप में इनपुट प्राप्त करता है, जहां अंतिम तत्व स्टैक के शीर्ष है।

शून्य-गहराई और अजगर के साइन-एडजस्टिंग मोडुलो ऑपरेटर को फ़िल्टर करने के लिए 0y ट्रिक का उपयोग करता है ताकि सूची का हिस्सा काट दिया जा सके।

Comments

सिर्फ ले क्यों नहीं f(s,t,d)?

— कोल

@ अनपैकिंग के लिए धन्यवाद! हालाँकि, मैं नहीं देख सकता कि आपके द्वारा क्या मतलब था f(s,t,d)(इनपुट पूरे स्टैक है)।

— ऊरीएल

अनपैकिंग के लिए भयानक विचार, हालांकि मुझे नहीं लगता कि आपको इसके लिए मुझे श्रेय देना चाहिए (मैं बस अलग से चर लेने का सुझाव दे रहा था)। इनपुट कल्पना आपको गहराई लेने देती है और स्टैक से अलग चर के रूप में बदल जाती है: "इनपुट और आउटपुट एक सूची में हो सकता है, सरणी, एक सीमांकक के साथ स्ट्रिंग, एक समय में एक तत्व में पारित, या कोई अन्य उचित प्रारूप। आउटपुट इनपुट के समान प्रारूप में होना चाहिए। "

— कोल

आप 1 बाइट के साथ बचा सकते हैं r=-t%d-d। इसके अलावा, बाइट की गिनती बनाए रखने के s*0**dसाथ , s*(d<1)लेकिन शायद पठनीयता में सुधार होता है (ऐसा नहीं है कि यह लक्ष्य है)। मुझे नहीं पता था कि 0**0==1पायथन में हालांकि, यह दिलचस्प है।

— बेन फ्रैंकेल

@BenFrankel मैं -t%d-dएक मान के रूप में सहेज नहीं सकता (जैसा कि मैंने पहले किया था), क्योंकि जब यह होता dहै तो 0यह विभाजन-दर-शून्य अपवाद को ट्रिगर करेगा।

— यूरिल

Answer 7

जावास्क्रिप्ट ईएस 6, 109 92 बाइट्स

x=>{for(i=x.shift(),i=i>0?i:-i,j=x.shift();i-->0&&j>0;)x=x.splice(j,1).concat(x);return x}

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

पूर्णांकों की एक सरणी के रूप में इनपुट प्राप्त करता है।
तीर के लिए भी गिनती है: पी

स्पष्टीकरण:

सूची के पहले दो तत्वों को निकालने के लिए कोड शिफ्ट फ़ंक्शन का उपयोग करता है।

इसके बाद पहले तत्व का पूर्ण मूल्य प्राप्त होता है, जो कि घुमावों की संख्या है।

चूंकि जावास्क्रिप्ट शून्य अनुक्रमित है, गहराई सूचकांक को 1 से कम करने की आवश्यकता है।

यदि गहराई सूचकांक 0 या 1 था, तो कुछ भी नहीं बदलना चाहिए, लेकिन कमी के कारण, 0 का सूचकांक परिवर्तन का कारण होगा। इसलिए लूप से बाहर निकलें यदि गहराई सूचकांक <= 0 नहीं है।

ब्याह (ए, बी) फ़ंक्शन सरणी से इंडेक्स शुरू करने के साथ लंबाई बी के उप-सरणी देता है और उन तत्वों के बिना मूल सरणी को छोड़ देता है।

जब मूल सरणी के शेष भाग के साथ समाप्‍त किया जाता है, तो यह गहराई इंडेक्स पर सरणी का एकल घुमाव है।

इस ऑपरेशन को n बार करने से, जहाँ n मोड़ की संख्या है, परिणामस्वरूप सरणी रोल ऑपरेटर का परिणाम है।

Answer 8

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

lambda r:r[2:r[1]+2][r[0]:]+r[2:r[0]]+r[r[1]+2:]

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

Answer 9

टीआई-बेसिक, 141 150 बाइट्स (नॉनकमेटिंग)

Prompt L1
L1(1→T
L1(2→D
seq(L1(C),C,3,dim(L1→L1
If TD>0
Then
For(A,1,T
L1(1→B
For(C,2,D
L1(C→L1(C–1
End
B→L1(D
End
End
If TD<0
Then
For(A,1,-T
L1(D→B
For(C,D,2,-1
L1(C–1→L1(C
End
B→L1(1
End
End
L1

संपादित करें: निश्चित मामला जहां गहराई शून्य है (+9 बाइट्स)

TI-Basic 0-लंबाई सूचियों का समर्थन नहीं करता है, इसलिए यह दृष्टिकोण दो-लंबाई इनपुट के लिए काम नहीं करेगा।

स्पष्टीकरण:

Prompt L1                # 4 bytes, input list
L1(1→T                   # 7 bytes, turns
L1(2→D                   # 7 bytes, depth
seq(L1(C),C,3,dim(L1→L1   # 18 bytes, remove turns and depth from list
If TD>0                  # 6 bytes, if turns is positive and depth is nonzero (can't be negative)
Then                     # 2 bytes
For(A,1,T                # 7 bytes, do this 'turns' times
L1(1→B                    # 7 bytes, backup the first item
For(C,2,D                # 7 bytes, shuffle the rest along
L1(C→L1(C–1               # 12 bytes
End                      # 2 bytes
B→L1(D                   # 7 bytes, restore the backup to where it should be
End                      # 2 bytes
End                      # 2 bytes
If TD<0                  # 6 bytes, if T is negative and D is nonzero
Then                     # 2 bytes
For(A,1,-T               # 8 bytes, do this -'turns' times
L1(D→B                   # 7 bytes, backup the Dth item
For(C,D,2,-1             # 10 bytes, shuffle the items the other way
L1(C–1→L1(C              # 12 bytes
End                      # 2 bytes
B→L1(1                   # 7 bytes, restore backup to where it belongs
End                      # 2 bytes
End                      # 2 bytes
L1                       # 2 bytes, implicitly return

Comments

मुझे लगता है कि आपको 2-तत्व सूची मामले से निपटने के लिए कोड की आवश्यकता है; वर्तमान में इसमें त्रुटि होगी seq(।

— ५२ पर lirtosiast

Answer 10

बैच, 163 बाइट्स

@set s=
@set r=
@set/ad=%2,t=(%1%%d+d)%%d
:l
@shift
@set/af=t-=1,f^^=d-=1
@if %f% lss 0 (set r=%r% %2)else set s=%s% %2
@if not "%3"=="" goto l
@echo%r%%s%

कमांड-लाइन मापदंडों के रूप में इनपुट लेता है और अंतरिक्ष-पृथक सूची को आउटपुट करता है। के बीच मानकों tऔर dमें निकाले जाते हैं r, ताकि वे के लिए prepended किया जा सकता है चर sचर, जो अन्य पैरामीटर प्राप्त करने के बाद।