सांता कब तहखाने में प्रवेश करता है? (AOC दिवस 1)

Question

मैं निर्माता से अनुमति के साथ, Advent of Code के पहले दिन का दूसरा भाग पुनः प्रस्तुत कर रहा हूँ ।

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

एक प्रारंभिक कोष्ठक, (इसका मतलब है कि उसे एक मंजिल तक जाना चाहिए, और एक कोष्ठक को बंद )करना चाहिए, इसका मतलब है कि उसे एक मंजिल से नीचे जाना चाहिए।

अपार्टमेंट बिल्डिंग बहुत लंबा है, और तहखाने बहुत गहरा है; वह ऊपर या नीचे की मंजिलों को कभी नहीं पाएगा।

निर्देशों के एक सेट को देखते हुए, पहले चरित्र की स्थिति का पता लगाएं, जो उसे तहखाने में प्रवेश करने का कारण बनता है (मंजिल -1)।

उदाहरण के रूप में:

इनपुट के )कारण उसे चरित्र स्थिति 1 में तहखाने में प्रवेश करना पड़ता है।

इनपुट के ()())कारण उसे चरित्र स्थिति 5 में तहखाने में प्रवेश करना पड़ता है।

एक लंबा इनपुट यहां दिया गया है जो समाधान 1797 का उत्पादन करना चाहिए।

यह कोड गोल्फ है, इसलिए सबसे छोटा समाधान जीतता है!

Comments

क्या हमें उन सटीक वर्णों का उपयोग करना होगा?

— ब्लू

@muddyfish मूल चुनौतियों में इनपुट एक विशिष्ट रूप में दिए गए थे और इसलिए अक्सर चुनौती का एक महत्वपूर्ण हिस्सा इनपुटों को पार्स कर रहा था; जब मैं नहीं चाहता कि यह एक "गिरगिट समस्या" बन जाए, तो मुझे लगता है कि मूल की भावना यह है कि इनपुट कोष्ठक का एक स्ट्रिंग होना चाहिए। मुझे लगता है कि यह कुछ भाषाओं को दूसरों पर विशेषाधिकार देता है लेकिन मैं मतदाताओं से इस बात को ध्यान में रखूंगा कि जब समाधान के लिए पुरस्कार मिले।

— एक सीमन्स

Parenthifiable बाइनरी नंबरों से बहुत निकटता से संबंधित ... मैं बहुत दृढ़ता से महसूस नहीं करता कि यह एक डुबकी है, इसलिए मैं सिर्फ एक टिप्पणी छोड़ दूंगा।

— AdmBorkBork

@TimmyD मैं देख रहा हूं कि आपका क्या मतलब है लेकिन मुझे लगता है कि यह प्रश्न काफी अलग है कि प्रतिस्पर्धी उत्तर उस प्रश्न से बहुत अधिक आकर्षित नहीं कर पाएंगे!

— एक सीमन्स

मैं इसे SMBF (मूल रूप से BF) में हल करने की कोशिश कर रहा हूं, और यह भाषा SUCKS को डिबग करने के लिए ... उघ।

— mbomb007

Answer 1

जेली, 8 7 बाइट्स

O-*+\i-

1 बाइट को बंद करने के लिए @ Sp3000 को धन्यवाद!

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

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

O-*+\i-    Main link. Input: s (string)

O          Ordinal; replace each character with its code point.
           This maps "()" to [48, 49].
 -*        Apply x -> (-1) ** x.
           This maps [48, 49] to [1, -1].
   +\      Compute the cumulative sum, i.e., the list of partial sums.
     i-    Find the first index of -1.

Answer 2

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

try:input()
except Exception,e:print e[1][2]

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

चाल है पायथन के पार्सर को काम करने देना। फ़ंक्शन input()एक इनपुट स्ट्रिंग का मूल्यांकन करने की कोशिश करता है, और पहले बेजोड़ परेन पर एक त्रुटि फेंकता है। जब पकड़ा जाता है, तो यह त्रुटि होती है

SyntaxError('unexpected EOF while parsing', ('<string>', 1, 1, ')'))

जिसमें त्रुटि हुई, जिसमें वर्ण संख्या शामिल है।

Answer 3

पायथन, 79 77 बाइट्स

lambda m:[sum([2*(z<')')-1for z in m][:g])for g in range(len(m)+1)].index(-1)

ऐसा करने का एक बेहतर तरीका है, लेकिन मैं विचारों से बाहर हूं। इसके अलावा यह कोडगॉल्फ पर मेरी पहली पोस्ट है।

@ इरावन को धन्यवाद। 2 बाइट्स से दूर गोल्फिंग के लिए।

Comments

साइट पर आपका स्वागत है! यह एक बहुत अच्छी पहली पोस्ट है। :)

— एलेक्स ए।

आप की जगह ले सकता [0:g]द्वारा[:g]

— एर्वान

और यह प्रतिस्थापन 1 बाइट्स को मेरे विचार -2*ord(z)+81से सेव करता है2*(z<')')-1

— एरवान

Answer 4

अजगर 3, 59

सहेजे गए 3 बाइट्स grc के लिए धन्यवाद।

मैं वास्तव में पायथन में मैनुअल स्ट्रिंग इंडेक्सिंग करना पसंद नहीं करता। ऐसा गलत लगता है।

def f(x):
 c=q=0
 while-~c:c+=1-(x[q]>'(')*2;q+=1
 return q

Answer 5

सी, 55 बाइट्स

g;main(f){for(;f;g++)f+=81-getchar()*2;printf("%d",g);}

इसे यहाँ आज़माएँ ।

संपादित करें: मुझे यकीन नहीं है कि मैंने वहां अप्रयुक्त चर क्यों छोड़ा ...

Answer 6

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

0l'_*:~1#)

या

0l'_*~]1#)

या (डेनिस को क्रेडिट)

Wl+'_*:~1#

इसका परीक्षण यहां करें।

व्याख्या

ए सिमन्स के रूप में पहले से ही उल्लेख किया है, ()CJam के लिए एक भाग्यशाली विकल्प है क्योंकि वे क्रमशः वेतन वृद्धि / वृद्धि ऑपरेटर हैं। इसका मतलब है कि अगर हम शून्य से शुरू कर रहे हैं तो हम उस कदम की तलाश कर रहे हैं जिस पर सांता फर्श 1 पर पहुंचता है।

0   e# Push 0, the initial floor.
l   e# Read input.
'_* e# Riffle the input string with underscores, which duplicate the top of the stack.
:~  e# Evaluate each character, using a map which wraps the result in an array.
1#  e# Find the position of the first 1.
)   e# Increment because we're looking for a one-based index.

Answer 7

भूलभुलैया , 18 बाइट्स

+(+"#(!@
:  :
%2_,

इसे ऑनलाइन आज़माएं! यह उत्तर @ मार्टिनबटनर के साथ सहयोग करने का परिणाम था।

व्याख्या

सामान्य भूलभुलैया प्राइमर (मैं "सामान्य" कहता हूं, लेकिन मैं वास्तव में हर बार इसे फिर से लिखता हूं):

• भूलभुलैया एक स्टैक-आधारित 2 डी भाषा है, जिसमें निष्पादन पहले वैध चार (यहां शीर्ष बाएं) से शुरू होता है। प्रत्येक जंक्शन पर, जहां निर्देश सूचक को लेने के लिए दो या अधिक संभावित रास्ते होते हैं, स्टैक के शीर्ष को यह निर्धारित करने के लिए चेक किया जाता है कि आगे कहां जाना है। नेगेटिव लेफ्ट है, जीरो आगे है और पॉजिटिव राइट है।
• स्टैक अथक है और शून्य से भरा है, इसलिए एक खाली स्टैक से पॉपिंग एक त्रुटि नहीं है।
• स्रोत कोड के अंक संबंधित संख्या को धक्का नहीं देते हैं - इसके बजाय, वे स्टैक के शीर्ष को पॉप करते हैं और धक्का देते हैं n*10 + <digit>। यह बड़ी संख्या में आसान इमारत की अनुमति देता है। एक नया नंबर शुरू करने के लिए, उपयोग करें _, जो शून्य को धक्का देता है।

यह कोड थोड़ा अजीब है क्योंकि गोल्फिंग प्रयोजनों के लिए, मुख्य लूप दो कार्यों को एक में जोड़ता है। पहली पास की पहली छमाही के लिए, यहाँ क्या होता है:

+(+             Add two zeroes, decrement, add with zero
                This leaves -1 on the stack
"               NOP at a junction. -1 is negative so we try to turn left, fail, and
                turn right instead.
:               Duplicate -1

अब जब स्टैक को शीर्ष पर -1 के साथ आरंभ किया गया है, तो वास्तविक प्रसंस्करण शुरू हो सकता है। यहाँ मुख्य लूप क्या करता है।

,               Read a byte of input
_2%             Take modulo 2.
:+              Duplicate and add, i.e. double
(               Decrement
                This maps "(" -> -1, ")" -> 1
+               Add to running total
"               NOP at a junction. Go forward if zero, otherwise turn right.
:               Duplicate the top of the stack

अंतिम डुप्लिकेट हमारे द्वारा निष्पादित प्रत्येक पुनरावृत्ति के लिए स्टैक में एक तत्व जोड़ता है। यह महत्वपूर्ण है क्योंकि, जब हम शून्य से टकराते हैं और एनओपी पर आगे बढ़ते हैं, हम करते हैं:

#               Push stack depth
(               Decrement
!               Output as num
@               Terminate

Answer 8

Oracle SQL 11.2, 160 159 बाइट्स

SELECT MIN(l)FROM(SELECT l,SUM(m)OVER(ORDER BY l)p FROM(SELECT LEVEL l,DECODE(SUBSTR(:1,LEVEL,1),'(',1,-1)m FROM DUAL CONNECT BY LEVEL<=LENGTH(:1)))WHERE p=-1;

संयुक्त राष्ट्र के golfed

SELECT MIN(l) -- Keep the min level
FROM(
  SELECT l,SUM(m)OVER(ORDER BY l)p -- Sum the () up to the current row
  FROM(
    SELECT LEVEL l,DECODE(SUBSTR(:1,LEVEL,1),'(',1,-1)m -- ( equal 1 and ) equal -1 
    FROM DUAL 
    CONNECT BY LEVEL<= LENGTH(:1)
  )
)
WHERE p=-1 -- Keep the rows where the () sum is equal to -1

Answer 9

रेटिना ,22 21

! M` ^ ((\ () |?। (<- 2>)) +

इसे ऑनलाइन आज़माएं या बड़े परीक्षण के मामले में प्रयास करें। (बड़े परीक्षण मामले के लिए URL बड़ा है, मुझे बताएं कि क्या यह आपके लिए टूटता है, क्रोम में ठीक लगता है।)

1 बाइट ने मार्टिन को दिया धन्यवाद!

हम संतुलित कोष्ठकों के पहले सेट से मेल खाते हैं और इसे निकालते हैं, फिर हम उस परिणाम से मेल खाने वाले खाली स्ट्रिंग की संख्या की गणना करेंगे। मुझे यकीन नहीं है कि यह रेटिना में ऐसा करने का सबसे अच्छा तरीका है, खासकर अगर पीसीआरई मोड इसे छोटा बनाता है, लेकिन $#_प्रतिस्थापन का उपयोग करने से यह प्रतीत होता है कि एक त्रुटि और एक से अधिक मैच होने की समस्या के कारण यह अधिक लंबा है।

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

Comments

संता ने अपनी पोर्टल गन का इस्तेमाल किया ।

— mbomb007

Answer 10

Grep + AWK, 51 बाइट्स

grep -o .|awk '/\(/{s++}/)/{s--}s<0{print NR;exit}'

grepआदेश एक नई लाइन पर प्रत्येक चरित्र देता है।

Answer 11

पायथ, 13 बाइट्स

f!hsm^_1Cd<zT

व्याख्या

              - autoassign z = input()
f             - First where V returns Truthy.
          <zT -     z[:T]
    m         -    [V for d in ^]
        Cd    -     ord(d)
     ^_1      -      -1**^
   s          -   sum(^)
 !h           -  not (^+1)

इसे यहाँ आज़माएँ

पुराना एल्गोरिथ्म, 15 बाइट्स

f!h-/J<zT\(/J\)

स्पष्टीकरण:

                - autoassign z = input()
f               - First where V returns Truthy.
      <zT       -      z[:T]
     J          -     autoassign J = ^
    /    \(     -    ^.count("(")
           /J\) -    J.count(")")
   -            -   ^-^
 !h             -  not (^+1)

इसे यहाँ आज़माएँ

या अगर अलावा अन्य उपयोग वर्ण की अनुमति दी (और ), 9 बाइट्स (चलती इनपुट करने के लिए पूर्व प्रसंस्करण)

f!.v+<zT1

व्याख्या

          - autoassign z = input()
f         - First where V returns Truthy.
     <zT  -     z[:T]
    +   1 -    ^+"1"
  .v      -   eval(^)
 !        -  not ^

इसे यहाँ आज़माएँ

Answer 12

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

f=(s,t=s)=>s<')'?f(s.replace('()',''),t):t.length-s.length+1

()जब तक पहला चरित्र a नहीं है, तब तक मिलान वाले जोड़े को हटाकर पुन: कार्य करता है )। चेतावनी: इस तार पर कोशिश मत करो जो पर्याप्त नहीं है) । उदाहरण:

((()())()))
((())()))
(()()))
(()))
())
)

इस बिंदु पर यह देखता है कि कुल 12 वर्ण हटा दिए गए ताकि उत्तर 13 हो।

Comments

आप अपने जवाब में उस टिप्पणी को डाल सकते हैं।

— mbomb007

Answer 13

MATL , 12 11 बाइट्स

1 बाइट ने डेनिस के विचार का उपयोग करके बचा लिया -1 इनपुट स्ट्रिंग पर उठाया गया

1_j^Ys0<f1)

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

1_         % number -1
j          % take string input
^          % element-wise power. This transforms '('  to 1 and ')' to -1
Ys         % cumulative sum
0<         % true for negative values
f          % find all such values 
1)         % pick first. Implicit display

Answer 14

सीजाम, 12 10 बाइट्स

0q{~_}%1#)

इसे यहाँ आज़माएँ।

दो बाइट्स ने मार्टिन को धन्यवाद दिया।

स्पष्टीकरण:

0              Load 0 onto the stack
 q             Load input onto the stack without evaluating
  {  }       Code block
   ~_          Evaluate the next command and duplicate the top stack element. The format of the question is good for CJam and Golfscript since ) and ( are increment and decrement operators (though the wrong way round).
        %      Map this code block over the string. This yields an array of Santa's floor positions
         1#   Find the first instance of a 1, since decrement and increment are swapped
           )  Fix the off-by-1 error caused by zero-indexing

Answer 15

जावास्क्रिप्ट, 117 बाइट्स

o=f=0;i=prompt().split('');for(c in i){switch (i[c]){case '(':f++;break;case ')':f--;if(f<0){alert(o+1);i=[];}}o++;}

अन्य पात्रों की उपेक्षा करता है। उपयोग promptऔर alert।

Answer 16

पर्ल, 34 + 1 = 35 बाइट्स

$.+=s+.+++s+\)++while")"gt$_;$_=$.

डेनिस को कुछ टिप्स के लिए धन्यवाद।

के साथ भागो -pझंडे के । यह पर्ल 5.10 में काम करता है, लेकिन बाद के संस्करणों को यहां एक स्थान की आवश्यकता होती है:++ while

पुराना, अधूरा संस्करण:

$_ = <>;                # get a line of input
while ($_ lt ')') {     # while it begins with a (
    s/.//;              # remove the first (
    s/\)//;             # remove the first )
    $i += 2;            # increase index by 2
}
print $i + 1;           # print the position

Answer 17

पायथन, 44 बाइट्स

f=lambda s,i=1:i and-~f(s[1:],i-1+2*(s<')'))

मंजिल इसलिए iशुरू होती 1है कि हम iफाल्सी वैल्यू होने पर समाप्त हो जाते हैं 0। यदि समाप्त नहीं किया गया है, तो पुन: प्रथम वर्ण हटाए गए और उस वर्ण के आधार पर अपडेट की गई फ़्लोर संख्या के साथ परिणामी रूप से जोड़ें।

Answer 18

जावास्क्रिप्ट, 57 बाइट्स

p=>{c=0;for(i in p){c+=p[i]==')'?-1:1;if(c<0)return+i+1}}

बहुत सरल, बस इनपुट पर पुनरावृत्त करता है, अगर '(अगर' अगर ')'। पहले नकारात्मक पर लौटता है।

Answer 19

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

अनाम फ़ंक्शन।

->s{i,l=-1,0;l+=s[i+=1]>?(?-1:1 while l>-1;i+1}

Answer 20

सी, 73 बाइट्स

main(f,c){f=c=0;for(;f!=-1;c++){f+=1-((getchar()&1)<<1);}printf("%d",c);}

एसटीडीआईएन पर इनपुट की उम्मीद है; (और के अलावा कोई पात्र नहीं) इनपुट में नहीं दिखाई दे सकता (कम से कम जब तक हम उत्तर तक नहीं पहुँचते)। इनपुट ASCII होना चाहिए।

STDOUT पर उत्तर का उत्सर्जन करता है।

ASCII के लिए (और के बीच 1-बिट अंतर का उपयोग करता है )।

/* old-style arguments, implicitly int */
main(x, f)
{
    /* c is our character counter, f is the floor*/
    c = f = 0;
    /* increase c while f is not -1 */
    for (;f != -1; c++) {
        /* use difference in LSB to add one for (, subtract one for ) */
        f += 1-((getchar()&1)<<1);
    }
    /* answer */
    printf("%d", c);
}

अच्छी तरह से स्वरूपित संस्करण:

Comments

क्या आप बाइट को बचाने f=c=0के लिए लूप के आरंभीकरण में आगे बढ़ सकते हैं for(f=c=0;f!=...?

— AdmBorkBork 16

@TimmyD को वैश्विक बनाने के लिए बेहतर है कि वे ऑटो इनिशियलाइज़्ड हों।

— कोल कैमरून

Answer 21

पॉवरशेल, 75 65 62 बाइट्स

[char[]]$args[0]|%{$c+=(1,-1)[$_%40];$d++;if($c-lt0){$d;exit}}

पर के रूप में एक ऐसी ही तकनीक का उपयोग करता Parenthifiable द्विआधारी संख्या सभी इनपुट पात्रों के माध्यम से पाश के लिए, ध्यान में रखते हुए एक चल $cके ounter +1प्रत्येक के लिए (और -1प्रत्येक के लिए) है, तो परीक्षण हम नकारात्मक मारा है या नहीं (यानी, हम तहखाने में हैं)।

_{संपादित करें - अपने सूचकांकों के बजाय वास्तविक वर्णों पर पुनरावृत्ति करके 10 बाइट्स को बचाया 2 संपादित करें - मोडुलो के
लिए समानता की जांच को स्वैप करके 3 अतिरिक्त बाइट्स को बचाया गया है ताकि कास्टिंग निहित है}

Answer 22

मेथेमेटिका, 62 55 बाइट्स

Position[Accumulate[(-1)^ToCharacterCode@#],-1][[1,1]]&

सभी लंबे समारोह के नाम! सिमंस के सीजेएम उत्तर के समान ही काम करता है।

Answer 23

25 बाइट्स काटें

एकतरफा में आउटपुट। यह आपको एक मंजिल पर शुरू करता है, और 0 तक जाएगा।

1<\1_v#:+-*2%2~
:#._@>$1>

Answer 24

रैकेट (102)

(λ(s)(let l((c 0)(b 0)(s(string->list s)))(if(> 0 b)c(l(+ 1 c)((if(eqv?(car s)#\()+ -)b 1)(cdr s)))))

Ungolfed

(λ (input)
  (let loop ((count 0) (balance 0) (chars (string->list input)))
    (if (> 0 balance)
        count
        (loop (+ 1 count)
              ((if (eqv? (car chars) #\() + -) balance 1)
              (cdr chars)))))

Answer 25

एपीएल, 18 वर्ण

{1⍳⍨¯1=+\¯1*')'=⍵}

अंग्रेजी में:

• ¯1*')'=⍵: -1 जहां इनपुट = ")", 1 अन्यथा;
• +\: योग चल रहा है;
• 1⍳⍨¯1=: पहले -1 का सूचकांक खोजें।

Answer 26

लुआ, 92 89 87 बाइट्स

यह एक कमांड-लाइन तर्क में लेता है।

संपादित करें: 3 बाइट्स सहेजे गए

संपादित करें: 2 बाइट्स सहेजे गए, और एक बग को ठीक किया जो कि किनारे के मामलों पर हो सकता है, यह अब अपने निकास कोड के माध्यम से आउटपुट करता है

r=0i=0(...):gsub(".",function(c)i=i+1r=r+(c==")"and-1or 1)if r<0then os.exit(i)end end)

Ungolfed

r,i=0,0                     -- set r (the actual floor), and i(the character count)
(...):gsub(".",function(c) -- apply an anonymous functions on each character of the input
  i,r=i+1,                  -- increment i
      r+(c==")"and -1 or 1) -- decrement r if c==")", increment it otherwise
  if r<0 then os.exit(i)end -- if r==-1, exit and output the current index
end)

Answer 27

के / कोना , २३ २१ बाइट्स

अनावश्यक कोष्ठकों को हटाकर 2 बाइट्स बचाए गए।

{1+(+\1 -1"()"?x)?-1}

उपयोग:

k){1+(+\1 -1"()"?x)?-1} "())"
3

Answer 28

पर्ल, 40 + 1 = 41 बाइट्स

$y++,($i+=/\(/*2-1)<0&&last for/./g;$_=$y

-pध्वज की आवश्यकता है :

$ perl -pe'$y++,($i+=/\(/*2-1)<0&&last for/./g;$_=$y' <<< '()())'
5
$ perl -pe'$y++,($i+=/\(/*2-1)<0&&last for/./g;$_=$y' 1797.txt
1797

मान्य इनपुट मानता है।

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

                                           # -p read line by line into $_ and auto prints at the end
        $y++,                              # Counter for steps taken
             ($i+=/\(/*2-1) < 0            # The match /\(/ will give 1 or 0 in a numeric context 1 for `(` and 0 for anything else
                                           # times it by 2 and subtracting -1 will yield 1 or -1
                               && last     # End the iteration if $i < 0
for/./g;                                   # Iterate over each items in the input
                                      $_=$y# Print the output

Answer 29

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

(s,r,f=0)=>s.split``.map((l,i)=>(f+=l=='('?1:-1,f<0?r=r||++i:0))&&r

पहले तर्क के रूप में इनपुट लेता है

व्याख्या

(s, r, f=0)                                  //Gets string, declares r and f to equal undefined and 0
         =>
            s.split``                        //Splits string into character array
            .map(                            //Loops over array
                 (l, i)=>(
                         f +=                //Increment f
                         l=='(' ? 1 : -1,    //By either 1 or -1 depending on character
                         f<0 ?               //If the floor is less than 0
                         r=r||++i            //And is first time below, r equals index (+1 to make it '1 indexed not 0')
                         : 0)
                         &&r                   //Return index

Answer 30

पायथन (3.5), 78 71 62 बाइट्स

एक पुनरावर्ती समाधान

f=lambda s,p=0,v=0:p if v<0else f(s[1:],p+1,v+2*(s[0]<')')-1) 

यह मिनी गोल्फ के लिए इस समाधान के समान है

हम मान सकते हैं कि संता हमेशा तहखाने में पहुंचता है