अनुक्रमण चा-चा स्लाइड

12

परिचय:

हालांकि मेरे पास मूल रूप से मेरे सिर में एक डच गीत था, जहां गीत के बोल हैं: " दोए 'एन स्टापेज नोर वोरेन, एन' एन स्टेपजे टेरुग " (जिसका अनुवाद " थोड़ा कदम आगे ले जाएं, और थोड़ा कदम पीछे हटें " "), जब मैंने पूर्ण गीतों की खोज की, मुझे एहसास हुआ कि वे केवल आगे-पीछे होते हैं, और कभी भी बग़ल में नहीं होते हैं।

इसलिए, अब मैं मिस्टर सी द स्लाइड मैन उर्फ ​​डीजे कैस्पर - चा-चा स्लाइड के गीतों का उपयोग करता हूं इस चुनौती के लिए ।

यदि हम बाकी सब चीजों को नजरअंदाज करते हैं और केवल उल्लिखित मात्राओं सहित "बाएं", "दाएं", "वापस", और "हॉप" (मैं "हॉप" को आगे की ओर गिना जाता है) जैसे शब्दों को देखता हूं, तो पूर्ण गीत में निम्नलिखित सूची होगी ( मैं यहाँ संक्षिप्त परिचय LRBH का उपयोग कर रहा हूँ):

LBHRLLBHRLBHHRRLLLRLBHHHHRRLLLBHHHHHRLRLRLHRLLBHHLRLBHH

यहाँ एक पूरा करने योग्य जावास्क्रिप्ट कोड-स्निपेट (स्थान बचाने के लिए) में पूर्ण गीत के बोल, जहाँ चाल और मात्रा को समायोजित कोष्ठक से घिरा हुआ है:

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

चुनौती:

अब चुनौती पर ही। हम एक, दो, या तीन आदानों ले † । उनमें से एक सूचकांक-पूर्णांक की एक सूची है (इसलिए 0-अनुक्रमित के लिए गैर-नकारात्मक या 1-अनुक्रमित के लिए सकारात्मक)। (अन्य इनपुट वैकल्पिक हैं और चुनौती नियमों में समझाया गया है।)

प्रत्येक परीक्षण का मामला एक स्थिति में शुरू होगा {x=0, y=0}।
अब चाल और हटाने के गीत-सूची का उपयोग करें इनपुट-सूची के दिए गए सूचकांकों पर सभी चाल को । फिर चालों पर 'चलना' (इनपुट-सरणी के सबसे बड़े सूचकांक तक) और उस स्थिति को आउटपुट करें जिसे आप समाप्त करेंगे।

चाल के रूप में निर्देशांक बदल जाएगा:
- R: x+1
- L: x-1
- H: y+1
- B:y-1

चुनौती नियम:

  • चाल-सूची को आप अपनी इच्छानुसार एक्सेस कर सकते हैं। An: एक अतिरिक्त इनपुट हो सकता है; डिस्क पर एक अलग फ़ाइल में हो सकता है जिसे आप पढ़ेंगे; आपके द्वारा उपयोग किए जाने वाले एक वर्ग-स्तरीय चर में हो सकता है। यह के रूप में होगा L, R, Bऔर H, हालांकि (एक स्ट्रिंग या चरित्र-सूची / सरणी हो सकता है) ताकि आप के रूप में चलता रहता है-सूची नहीं सहेजा जा सकता 1है और -1या पूर्णांकों।
  • ऊपर दी गई चाल-सूची हार्ड-कोडेड है और हमेशा समान रहेगी। (यह भी क्यों कि इसे इनपुट के रूप में लेने के बजाय इसे क्लास-लेवल फील्ड के रूप में रखना ठीक है यदि यह आपके उत्तर की बाइट-काउंट में मदद करता है।)
  • इनपुट-सूची 0-अनुक्रमित या 1-अनुक्रमित (आप तक) दोनों हो सकती है
  • हम सूची के सबसे बड़े सूचकांक को छोड़कर केवल 'चलते' हैं।
    • Also: आपको इनपुट-सरणी के अंतिम आइटम के बजाय इस अंतिम आइटम को अलग पूर्णांक इनपुट के रूप में लेने की अनुमति है।
  • हमारे द्वारा समाप्त किए जाने वाले x और y निर्देशांक का आउटपुट किसी भी उचित प्रारूप में हो सकता है (पूर्णांक-सरणी में दो आइटम, सीमांकित स्ट्रिंग, दो अलग-अलग लाइनों पर STDOUT पर मुद्रित, आदि)
  • आप मान सकते हैं कि इनपुट-लिस्ट को सबसे कम से उच्चतम (या उच्चतम से सबसे कम यदि आप पसंद करते हैं, तो जिस स्थिति में पहला आइटम चाल-सूची का प्रारंभिक आकार है - यदि अलग इनपुट के रूप में नहीं लिया गया है)। और इसमें कोई डुप्लिकेट इंडेक्स भी नहीं होगा।
  • यदि इनपुट-सूची का सबसे बड़ा सूचकांक ऊपर की चालों की सूची से बड़ा है (55 चाल ऊपर की सूची में हैं), हम सूची की शुरुआत के आसपास फिर से लपेटते हैं (जितनी बार आवश्यक हो, सबसे बड़े सूचकांक के आधार पर। इनपुट का)।
  • आपको y,xइसके बजाय आउटपुट की अनुमति है x,y, लेकिन यदि आप करते हैं तो कृपया इसे अपने उत्तर में निर्दिष्ट करें।

उदाहरण:

इनपुट: [0,4,8,10,13,14,27,34,42,43,44,50,53,56,59,60,64]

यहाँ चालें और (0-अनुक्रमित) सूचक एक के ऊपर एक:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
L, B, H, R, L, L, B, H, R, L, B, H, H, R, R, L, L, L, R, L, B, H, H, H, H, R, R, L, L, L, B, H, H, H, H, H, R, L, R, L, R, L, H, R, L, L, B, H, H, L, R, L, B, H, H, L, B, H, R, L, L, B, H, R, L

इनपुट-सूची के सूचकांकों को हटाते हुए, हमारे पास निम्नलिखित चाल-सूची शेष होगी:

1, 2, 3, 5, 6, 7, 9,11,12,15,16,17,18,19,20,21,22,23,24,25,26,28,29,30,31,32,33,35,36,37,38,39,40,41,45,46,47,48,49,51,52,54,55,57,58,61,62,63
B, H, R, L, B, H, L, H, H, L, L, L, R, L, B, H, H, H, H, R, R, L, L, B, H, H, H, H, R, L, R, L, R, L, L, B, H, H, L, L, B, H, L, H, R, B, H, R

अब यदि हम {0, 0}शेष चालों की स्थिति से चलते हैं , तो हमारे पास हर चाल के बाद निम्नलिखित नए निर्देशांक होंगे:

{0,0};B,{0,-1};H,{0,0};R,{1,0};L,{0,0};B,{0,-1};H,{0,0};L,{-1,0};H,{-1,1};H,{-1,2};L,{-2,2};L,{-3,2};L,{-4,2};R,{-3,2};L,{-4,2};B,{-4,1};H,{-4,2};H,{-4,3};H,{-4,3};H,{-4,5};R,{-3,5};R,{-2,5};L,{-3,5};L,{-4,5};B,{-4,4};H,{-4,5};H,{-4,6};H,{-4,7};H,{-4,8};R,{-3,8};L,{-4,8};R,{-3,8};L,{-4,8};R,{-3,8};L,{-4,8};L,{-5,8};B,{-5,7};H,{-5,8};H,{-5,9};L,{-6,9};L,{-7,9};B,{-7,8};H,{-7,9};L,{-8,9};H,{-8,10};R,{-7,10};B,{-7,9};H,{-7,10};R,{-6,10}

तो अंतिम उत्पादन होगा: {-6, 10}

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
  • डिफ़ॉल्ट लूपोल्स वर्जित हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ना अत्यधिक अनुशंसित है।

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

0-indexed input: [0,4,8,10,13,14,27,34,42,43,44,50,53,56,59,60,64]
1-indexed input: [1,5,9,11,14,15,28,35,43,44,45,51,54,57,60,61,65]
Output: {-6, 10}

0-indexed input: [55]    (Note: There are 55 moves in the unmodified list)
1-indexed input: [56]    (Note: There are 55 moves in the unmodified list)
Output: {-6, 11}

0-indexed input: [0,1,4,5,6,9,10,15,16,17,19,20,27,29,30,37,38,39,41,44,45,46,49,51,52]
1-indexed input: [1,2,5,6,7,10,11,16,17,18,20,21,28,30,31,38,39,40,42,45,46,47,50,52,53]
Output: {10, 16}

0-indexed input: [2,3,7,8,11,12,13,14,18,21,22,23,24,25,26,31,32,33,34,35,36,38,40,42,43,47,48,50,53]
1-indexed input: [3,4,8,9,12,13,14,15,19,22,23,24,25,26,27,32,33,34,35,36,37,39,41,43,44,48,49,51,54]
Output: {-18, -7}

0-indexed input: [0]
1-indexed input: [1]
Output: {0, 0}

0-indexed input: [4,6,7,11,12,13,15,17,20,28,31,36,40,51,59,66,73,74,80,89,92,112,113,114,116,120,122,125,129,134,136,140,145,156,161,162,165,169,171,175,176,178,187,191,200]
1-indexed input: [5,7,8,12,13,14,16,18,21,29,32,37,41,52,60,67,74,75,81,90,93,113,114,115,117,121,123,126,130,135,137,141,146,157,162,163,166,170,172,176,177,179,188,192,201]
Output: {-17, 37}

0-indexed input: [25,50,75,100,125,150,175,200,225,250]
1-indexed input: [26,51,76,101,126,151,176,201,226,251]
Output: {-28, 49}
code-golf  number  subsequence 
— केविन क्रूज़सेन
स्रोत
क्या हम निर्देशांक को रिवर्स ऑर्डर में आउटपुट कर सकते हैं?
— शैगी
3
@ शागि उम्म, ज़रूर, क्यों नहीं। जब तक आप स्पष्ट रूप से इसे अपने उत्तर में निर्दिष्ट करते हैं।
— केविन क्रूज़सेन
@ अर्नुलद हाँ, चालें प्रदर्शित होती हैं और कभी नहीं बदलेंगी। मैं शायद इसे और अधिक स्पष्ट रूप से स्पष्ट करूंगा अगर यह अभी तक स्पष्ट नहीं था। (जो भी है कि आप इसे एक हार्डकोड क्लास-स्तरीय फ़ील्ड के रूप में ले सकते हैं यदि यह आपकी बाइट-काउंट को लाभान्वित करेगा।)
— केविन क्रूज़सेन
क्या आउटपुट फ़्लोट की जोड़ी हो सकता है?
— जकोब
1
चुनौती के लिए बहुत देर हो चुकी है, लेकिन आपके दो परीक्षण मामलों में 1-अनुक्रमित मामले के लिए गलत इनपुट है: छठे एक में एक अतिरिक्त 82, और तीसरे टेस्टकेस में 39 के बजाय 29 (छंटाई इंगित करता है कि आप का इरादा हो सकता है) वास्तव में 28/29 हो सकता है, लेकिन अपेक्षित आउटपुट 38/39 का उपयोग करने से है)।
— सूंदर - मोनिका

जवाबों:

4

05AB1E , 15 12 बाइट्स

बच निकले 3 बाइट्स एग्री टू द आउटगॉल्फ

ÝsKèIêRS¢2ôÆ

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

Ý                 # push range [0 ... input_int]
 sK               # remove all elements in input_list from this range
   è              # cyclically index into the moves-list with the remaining elements
    Iê            # push the unique chars of the move-list, sorted
      R           # reverse
       S¢         # count the occurrences of each char in "RLHB"
         2ô       # split into 2 parts
           Æ      # reduce each part by subtraction
— Emigna
स्रोत
1
अच्छा जवाब! के बारे में भी नहीं जानता था Æ। बस सभी चालों और उपयोग गिनती करने के लिए स्मार्ट तरीका Æके लिए अंतर की गणना करने के RLलिए और BHजोड़े।
— केविन क्रूज़सेन
Æहमेशा के लिए अस्तित्व में है, है ना? मुझे ऐसा लगता है, क्योंकि मुझे इसके बारे में पता नहीं था। मुझे लगता है कि आज्ञाओं की तरह लगता है कि "नया" शुरू से ही अस्तित्व में है, लेकिन मुझे कभी नहीं पता था कि उन्हें कैसे उपयोग करना है। ओह, +1
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn: यह वास्तव में हमेशा के लिए अस्तित्व में है;)
— एमीना
7

रूबी , 98 ... 58 55 बाइट्स

->a{([*0..a[-1]]-a).sum{|c|-1i**(m[c%55].ord%19)}.rect}

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

स्पष्टीकरण:

मुख्य चाल चालों का प्रतिनिधित्व करने के लिए जटिल संख्याओं का उपयोग कर रही है: 'B' -i, 'H' + i, 'L' -1 है और 'R' +1 है। यदि हम सभी चालों को जटिल संख्याओं में बदलते हैं, तो एक योग के साथ हमें सही परिणाम मिलता है।

मैंने अलग-अलग तरीकों की कोशिश की, लेकिन फिर मुझे जादू नंबर 19 मिला: हमें रेगेक्स से मेल खाने की जरूरत नहीं है क्योंकि:

B  is ASCII 66; 66%19=9  and i^9  = i
H  is ASCII 72; 72%19=15 and i^15 =-i
L  is ASCII 76; 72%19=0  and i^0  = 1
R  is ASCII 82; 82%19=6  and i^6  =-1

तो, उस सब को एक साथ रखो, योग, साइन को पलटना, और हम कर रहे हैं।

धन्यवाद बाइट -3 बाइट्स के लिए

— जीबी
स्रोत
जटिल संख्या का चतुर उपयोग! चूंकि चाल स्ट्रिंग तय हो गई है, आप के (m*c+m)[c]साथ बदल सकते हैं m[c%55]।
— जैकब
4

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

चुनौती नियमों के अनुसार, यह कोड वैश्विक-स्कोप स्ट्रिंग m को चालों की सूची रखने की उम्मीद करता है। (3 बाइट्स की बचत, जैसा कि @KevinCruijssen द्वारा सुझाया गया है।)

इनपुट को 0-आधारित सूचकांकों की सूची के रूप में लेता है, जो निम्नतम से उच्चतम तक का आदेश दिया जाता है।

a=>a.map(g=i=>j++<i&&g(i,p=m.search(m[~-j%55])*3%5,x+=--p%2,y-=--p%2),j=x=y=0)&&[x,y]

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

कैसे?

प्रत्येक चाल चरित्र चाल स्ट्रिंग में अपनी स्थिति में बदल जाता है "LBHR..."। हम परिणाम को 3 से गुणा करते हैं और एक मॉड्यूल 5 लागू करते हैं , जो पी देता है । हम तो है:

  • dx = ((पी -1) मॉड 2)
  • डाई = - ((पी -2) मॉड २)

जहाँ मॉड बी का चिन्ह है a ।

 character | position | * 3 | mod 5 | dx | dy
-----------+----------+-----+-------+----+----
    'L'    |     0    |  0  |   0   | -1 |  0
    'B'    |     1    |  3  |   3   |  0 | -1
    'H'    |     2    |  6  |   1   |  0 | +1
    'R'    |     3    |  9  |   4   | +1 |  0
— Arnauld
स्रोत
3

जेली , 14 बाइट्स

Rḟị⁵ċⱮ⁵QṢṚ¤_2/

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

तर्क 1 / वाम तर्क: अधिकतम 1-आधारित सूचकांक।
तर्क 2 / सही तर्क: 1-आधारित सूचकांक।
तर्क 3: एक स्ट्रिंग के रूप में चलती है। यदि इस उद्देश्य के लिए तीसरी कमांड-लाइन तर्क का उपयोग किया जाता है, तो फ़ंक्शन अभी भी पुन: प्रयोज्य है।

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

जावा 10, 129 119 112 107 100 86 बाइट्स

a->m->{var r=new int[2];for(;m-->0;)r[s[m%55]/73]-=a.add(m)?s[m%55]*3%5-2:0;return r;}

अतिरिक्त इनपुट के रूप में अधिकतम लेता है; चाल-सूची वर्ग-स्तर पर एक चरित्र-सरणी है।

@Emigna के 05AB1E उत्तर से प्रेरित ।
-7 बाइट्स @Jakob को धन्यवाद ।
-14 बाइट्स @Gobits को धन्यवाद ।

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

स्पष्टीकरण:

a->m->{              // Method with Integer-Set & int parameters and int-array return
  var c=new int[2];  //  [x,y] result-array, starting at {0,0}
  for(;m-->0;)       //  Use the `m` input as index, and loop in the range (`m`, 0]
    r[s[m%55]/73]-=  //   Subtract from either x or y based on the character:
     a.add(m)?       //    If the input-set doesn't contain the current index `m`:
      s[m%55]*3%5-2  //     Modify the x or y coordinate based on the character
     :               //    Else:
      0;             //     Leave the x or y coordinate unchanged
  return r;}         //  Return count(R)-count(L) and count(H)-count(B) as result

s[m%55]/73वर्ण के आधार पर x या y में से किसी एक का समन्वय होता है ( इसे ऑनलाइन आज़माएं ):

Letter    Unicode value    /73

B         66               0
H         72               0
L         76               1
R         82               1

s[m%55]*3%5-2सही +1या -1पात्र के आधार पर नक्शे ( इसे ऑनलाइन आज़माएं ):

Letter    Unicode value    *3     %5    -2

B         66               198    3     1
H         72               216    1     -1
L         76               228    3     1
R         82               246    1     -1
— केविन क्रूज़सेन
स्रोत
1
यदि आप अनुक्रमणिका सूची को एक उत्परिवर्ती सेट के रूप में लेते हैं तो आप शर्त के a.add(m)रूप में उपयोग कर सकते ifहैं।
— जकोब
और int c[]हो सकता है int[]c।
— जकॉब
1
@ जाकोब आह, int c[]पिछले संस्करण से था , जहां मैंने अभी भी उपयोग iकरने के बजाय एक सूचकांक का उपयोग किया था m। और एक सेट का उपयोग करने के addबजाय स्मार्ट !contains, धन्यवाद!
— केविन क्रूज़सेन
1
आप c[2]धुरी (के साथ s[m%55]/73) का उपयोग करके अंत में बाइट-हॉगिंग घटाव से बच सकते हैं और इसे कुछ इस तरह से चला सकते हैं 3*s[m%55]%5-2(काश मैं उसे छोटा करने का एक तरीका देख सकता, लेकिन ...)। एक टर्नरी के साथ, यह a->m->{var c=new int[2];for(;m-->0;)c[s[m%55]/73]-=a.add(m)?3*s[m%55]%5-2:0;return c[1]+","+c[0];}98 के लिए है।
— जोबिट्स
@Geobits धन्यवाद! और -12 बृज के int[]बजाय केवल लौटकर अधिक बाइट करता है । :)
— केविन क्रूज़सेन
2

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

bसूचकांक सूची (ए set) है और lअंतिम सूचकांक है। इस कदम सूची (एक स्ट्रिंग या चरित्र सूची) के रूप में मुक्त दिखाई देता है s। यह GB के रूबी उत्तर का एक पोर्ट है , और दृष्टिकोण का स्पष्टीकरण वहां पाया जा सकता है।

def f(b,l):r=sum(-1j**(ord(s[i%55])%19)for i in set(range(l))-b);print(r.real,r.imag)

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

Ungolfed

def f(b, l):
    r = sum(
        -1j ** (ord(s[i % 55]) % 19)
        for i in set(range(l)) - b
    );
    print(r.real, r.imag)
— जेकब
स्रोत
1

क्लीन , 148 ... 130 बाइट्स

import StdEnv
$i=foldr(\a(x,y)|any((==)a)i=(x,y)=case m.[a rem 55]of'H'=(x,y+1);'B'=(x,y-1);'L'=(x-1,y);_=(x+1,y))(0,0)[0..last i]

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

फ़ंक्शन को परिभाषित करता है $ :: [Int] -> (Int, Int) , foldrलागू कार्रवाई खत्म होने से पहले चाल से हटाए जाने वाले सूचकांकों (सबसे छोटी से सबसे बड़ी) की सूची लेता है (0,0)।

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