15

ऐलिस और बॉब एक कार्ड गेम खेलना पसंद करते हैं, जिसमें कार्ड्स के डेक को लगातार नॉनगनेटिव पूर्णांकों के साथ गिना जाता है।

ऐलिस का डेक पर फेरबदल करने का एक विशेष तरीका है, यद्यपि। सबसे पहले, वह डेक से शीर्ष कार्ड लेती है और इसे डेक के नीचे रखती है। फिर वह अगला कार्ड निकालती है, और उसके साथ एक ढेर शुरू करती है। फिर, फिर से वह शीर्ष कार्ड को नीचे तक ले जाती है, और नए शीर्ष कार्ड को ढेर पर रख देती है। वह इस प्रक्रिया को तब तक दोहराती है जब तक कि वह डेक को खाली न कर दे, जिस बिंदु पर ढेर नया डेक है।

  deck     |  pile
-----------+-----------
 3 1 4 0 2 | 
 1 4 0 2 3 | 
 4 0 2 3   |         1
 0 2 3 4   |         1
 2 3 4     |       0 1
 3 4 2     |       0 1
 4 2       |     3 0 1
 2 4       |     3 0 1
 4         |   2 3 0 1
           | 4 2 3 0 1
 4 2 3 0 1 |

^{चित्र 1: एलिस ने 5-कार्ड डेक "3, 1, 4, 0, 2" पर अपना फेरबदल किया। कार्ड के पीछे सभी बाईं ओर हैं।}

एक दिन, बॉब ने घोषणा की कि वह एक सप्ताह की छुट्टी ले रहा है। ऐलिस, खेल के साथ खेलने के लिए कोई भी नहीं है, उसके दोस्त ईव को प्रभावित करता है। अब, ईव एक बेशर्म धोखेबाज है, इसलिए जब वह ऐलिस की अजीबोगरीब फेरबदल देखता है, तो उसे पता चलता है कि वह अपने फायदे के लिए पहले से डेक को ढेर कर सकता है!

जब ईव पहले दिन के बाद घर जाता है, तो वह गेम के बारे में कुछ विश्लेषण करती है और यह पता लगाती है कि कार्ड के ऑर्डर 0, 1, 2, 3, 4, 5, ... में उसके सबसे अच्छे हालात हैं। डेक में कितने कार्ड थे, हालांकि वह अपनी बांह पर कुछ कोड लिखने के लिए एक अप्रशिक्षित योजना को पकड़ता है, जब वह दौड़ता है, तो डेक का आकार लेता है और आदेश को दिखाता है कि ईव को कार्ड लगाने की जरूरत है, ताकि जब ऐलिस डेक को फेरबदल करता है, अंतिम डेक 0, 1, 2, 3, क्रम में है ...

यह वास्तव में ईव के लिए कोई मायने नहीं रखता है कि कोड किस भाषा में है (वह उन सभी को जानता है), या क्या कोड एक फ़ंक्शन है जो पूर्णांक तर्क ले रहा है और एक सरणी लौटा रहा है, या एक कमांड लाइन तर्क या STDIN के माध्यम से इनपुट लेने वाला एक पूरा कार्यक्रम है। और STDOUT को परिणाम लिखना। हालांकि, उसे ऐलिस को देखने और उसे पकड़ने की संभावना को कम करने के लिए कोड की यथासंभव आवश्यकता होती है।

अनैतिक रूप से यह हो सकता है, क्या आप लोग ईव को बाहर निकालने में मदद कर सकते हैं?

उदाहरण इनपुट और आउटपुट:

in  out
 1  0
 2  0 1
 5  2 4 0 3 1
10  2 9 4 8 0 7 3 6 1 5
52  6 51 25 50 12 49 24 48 1 47 23 46 11 45 22 44 5 43 21 42 10 41 20 40 2 39 19
    38 9 37 18 36 4 35 17 34 8 33 16 32 0 31 15 30 7 29 14 28 3 27 13 26

code-golf sequence array-manipulation

— algorithmshark
स्रोत

3

लवली टटोलना, मैं टूट जाएगा।

— atı

यह थोड़ा भ्रमित है कि आपके स्टैक शीर्ष पर संरेखित हैं। और स्टैक के क्रम को स्पष्ट रूप से बताने से भी प्रश्न को थोड़ा स्पष्ट करने में मदद मिलेगी।

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

वही डेक के लिए जाता है।

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

भी: क्या आप लंबाई 5 का नमूना लेकर हमें बरगला रहे हैं? shuffle(shuffle(range(5))) == range(5)

— बिगाड़ने की

@ सिंथिया मुझे लगता है कि ऐसा होता है कि 5-कार्ड डेक पर ऐलिस का फेरबदल एक निमंत्रण है। मैंने पोस्ट करते समय वास्तव में इसके बारे में नहीं सोचा था क्योंकि यह सामान्य रूप से पकड़ में नहीं आता है।

— एल्गोरिथमशार्क

5

गोल्फस्क्रिप्ट, 15 14 13 बाइट्स

])~,{\+)\+}/`

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

उदाहरण

$ golfscript alice.gs <<< 10
[2 9 4 8 0 7 3 6 1 5]

यह काम किस प्रकार करता है

])    # Collect the stack into an array and pop. This leaves [] below the input string.
~     # Interpret the input string.
,     # For input “N”, push the array [ 0 … N-1 ] (the pile).
{     # For each card on the pile:
  \+  # Put the card on top of the deck.
  )   # Remove a card from the bottom of the deck.
  \+  # Put the card on top of the deck.
}/    #
`     # Convert the deck into a string.

— डेनिस
स्रोत

1

आप {}/चार्ट ऑपरेटर के बजाय एक चार्ट को बचाने के लिए उपयोग कर सकते हैं ।

— हावर्ड

धन्यवाद! मुझे एक सरणी चाहिए थी, इसलिए मैंने मानचित्र का उपयोग किया। आदत की ताकत ...

— डेनिस

1

](पहले दो वर्ण प्रभावी रूप से इनपुट के नीचे एक खाली सरणी डालते हैं, जिससे आप बाद में बचत करते हैं []\ ।

— पीटर टेलर

धन्यवाद! मुझे यह पता लगाने में बहुत लंबा समय लगा कि यह ऑनलाइन दुभाषिया के साथ काम क्यों नहीं कर रहा है। स्टैक साफ़ करना भूल गए ...

— डेनिस

5

जूलिया, 83

u(n)=(a=[n-1:-1:0];l=Int[];[push!(l,shift!(push!(l,pop!(a)))) for i=1:length(a)];l)

लौटे वेक्टर में अंतिम तत्व डेक का शीर्ष है।

— gggg
स्रोत

4

गणितज्ञ, 92 77 46 बाइट्स

चर में इनपुट की उम्मीद है n:

l={};(l=RotateRight[{#-1}~Join~l])&/@Range@n;l

यह सिर्फ शाब्दिक रूप से एक कार्ड के ऊपर ले जाकर और फिर नीचे के कार्ड को ऊपर की तरफ करके फेरबदल का खेल है।

संपादित करें: आउटपुट स्टैक का ट्रैक रखने की आवश्यकता नहीं है, केवल पूर्णांक के माध्यम से पुनरावृति।

— मार्टिन एंडर
स्रोत

2

पायथन 2.7 - 57

d=[0]
for j in range(1,input()):d=[d.pop()]+[j]+d
print d

अच्छा और सरल, बस फेरबदल। गोल्फस्क्रिप्‍ट इसे कैसे करता है, इसके बहुत करीब है।

— isaacg
स्रोत

1

जे (13 वर्ण) और के (9)

जैसा कि यह पता चला है, यह फेरबदल को पूर्ववत् करने के लिए एक सरल प्रक्रिया है, और एपीएल-पसंद के पास तह कहावत /है ताकि उन्हें यथासंभव कम करने में मदद मिल सके।

J के साथ 13 चार लगते हैं (_1|.,)/@i.@-, जबकि K को केवल 9: की जरूरत है |(1!,)/!:। एपीएल भी इसी तरह का होगा।

यहां जे संस्करण का चरण-दर-चरण ट्रेस है।

(_1|.,)/@i.@- 4                  NB. recall that J is right-associative
(_1|.,)/@i. - 4                  NB. u@v y  is  u v y
(_1|.,)/@i. _4                   NB. monad - is Negate
(_1|.,)/ i. _4                   NB. @
(_1|.,)/ 3 2 1 0                 NB. monad i. is Integers, negative arg reverses result
3 (_1|.,) 2 (_1|.,) 1 (_1|.,) 0  NB. u/ A,B,C  is  A u B u C
3 (_1|.,) 2 (_1|.,) _1 |. 1 , 0  NB. x (M f g) y  is  M f x g y
3 (_1|.,) 2 (_1|.,) _1 |. 1 0    NB. dyad , is Append
3 (_1|.,) 2 (_1|.,) 0 1          NB. dyad |. is Rotate
3 (_1|.,) _1 |. 2 , 0 1          NB. repeat ad nauseam
3 (_1|.,) _1 |. 2 0 1
3 (_1|.,) 1 2 0
_1 |. 3 , 1 2 0
_1 |. 3 1 2 0
0 3 1 2

आप देख सकते हैं कि J में, हम पूर्णांकों की सारणी को उल्टा करते हैं, लेकिन K में हम बाद में करते हैं: ऐसा इसलिए है क्योंकि foldlJ की तुलना में K गुना अधिक है foldr।