एक चित्र को देखते हुए, एक्स खोजें

Question

एक्स खोजें

मैं गणित के सवालों से प्रेरित था, जिसमें किसी को दिए गए आकार के लिए "फाइंड एक्स" कहा जाता है। मूलतः, मैं सिर्फ एक स्ट्रिंग में चरित्र 'x' के x और y स्थान को प्रिंट करने के लिए चुनौती देने वाला था। लेकिन मुझे लगता था कि यह बहुत आसान होगा। इसलिए मैंने उन संदर्भों पर विचार किया जो वे सामान्य रूप से थे, और एक्स के बगल में एक लाइन की लंबाई का पता लगाने का निर्णय लिया जो कि उचित लगा।

एक स्ट्रिंग इनपुट को देखते हुए एससीआई लाइन्स के डायग्राम के साथ-साथ एक सिंगल 'एक्स' और संभावित जंक कैरेक्टर्स को एक ही लाइन की लंबाई प्रिंट करें, जिसमें सीधे 'एक्स' हो।

उदाहरण

इनपुट:

|
|
|x
|
|

ouput:

5

इनपुट:

|\
| \x
|  \
|___\

आउटपुट:

4

इनपुट:

Diagram of a Wobbly Line:
IRRELEVANTTEXT____
____     ____/
    \___/ X ;)   
      x

आउटपुट:

3

इनपुट:

  ______________
 / ____________ \
 |/ __________ \|
 ||/ ________ \||
 |||/ ______ \|||
 ||||/      \||||
 |||||/  x  |||||
 |||||\_____/||||
 ||||\_______/|||
 |||\_________/||
 ||\___________/|
  \_____________/

आउटपुट:

5

टिप्पणियाँ

• मान्य रेखा वर्ण हैं \/_|
• \ खुद के ऊपर बाईं और नीचे दाईं ओर जोड़ता है।
• / खुद के ऊपर दाएं और बाएं बाएं को जोड़ता है।
• _ खुद के बाएँ और दाएँ जोड़ता है
• | खुद के ऊपर और नीचे जोड़ता है
• एक पंक्ति हमेशा सीधी होगी, और केवल एक पंक्ति वर्ण n n बार दोहराया जाएगा।
• एक्स हमेशा लोअरकेस होगा, और यह हमेशा आरेख में केवल एक ही होगा।
• Adjecent से तात्पर्य x से ठीक एक वर्ण ऊपर, नीचे या इसके अलावा है।
• एक्स हमेशा एक लाइन के बगल में होगा।
• इनपुट में टैब कभी दिखाई नहीं देंगे।
• इनपुट और आउटपुट कोई भी स्वीकार्य प्रारूप हो सकता है।
• यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीत है!
• मज़े करो। कर दो। तुम मजे करो।

संदर्भ कार्यान्वयन

Comments

अच्छी चुनौती है, लेकिन मुझे लगता है कि इनपुट में कोई टैब्स की गारंटी देना बेहतर होगा। यह कहकर कि वे हो सकते हैं, आप प्रभावी रूप से हर किसी को 4 स्थानों में टैब बदलने के लिए कोड जोड़ने के लिए मजबूर कर रहे हैं, जिसका मुख्य चुनौती से कोई लेना-देना नहीं है।

— लेवल रिवर सेंट

हाँ, आपको एक अच्छी बात मिल गई है। मैं उसे छींक दूँगा।

— 1

आपको एक टेस्टकेस जोड़ना चाहिए, जिसमें @तनाव-परीक्षण उत्तरों के समान आकार हो ।

— orlp

बहुत चालाक चुनौती, मैं इसे हल करने के लिए इस्तेमाल किए जाने वाले कुछ रणनीति को देखने के लिए उत्सुक हूं

— डैरेन एच

tex.stackexchange.com/a/18354

— नील

Answer 1

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

EDIT: कुछ और बाइट्स को बचाने के लिए, x और w को इनलाइन करें ।

गोल्फ ( माना जाता है कि इनपुट आयत बनाने के लिए रिक्त स्थान के साथ गद्देदार है)

t=>([k=e=o=1,v=t.search`\n`+2,-1,-v].some(h=>i=({"|":v-1,"_":1,"/":v,"\\":v})[d=t[r=l=t.search`x`+h]]),[...t].map(_=>o+=(k&=t[l-=i]==d)+(e&=t[r+=i]==d)),o)

विस्तारित

/*
   G(<input string,space padded>) => line length
*/
G=t=> {

    /*
     ! Note that these two are inlined, in the "golfed" version !
     "w" - line "width"
     "x" - index of "x"
    */
    x=t.search`x`;
    w=t.search`\n`+1;

    /*
    Locate the "line"    
     l,r - left cursor, right cursor (for navigating along the line)
     k - left stop flag, e - right stop flag
     i - increment
     d - direction (char)
    */
    [k=e=o=1,v=w+1,-1,-w-1].some(h=>i=({"|":w,"_":1,"/":v,"\\":v})[d=t[r=l=x+h]]);

    /* 
     Travel along the line axis in both directions

     Note, the stop condition should rather be: while(k|e), 
     but we iterate over all the chars with map instead (as o is guaranteed to be < # chars),
     to save some space
    */
    [...t].map(_=>o+=(k&=t[l-=i]==d)+(e&=t[r+=i]==d));

    /* 
      Resulting line length
    */
    return o;
};

परीक्षा

G= 
t=>([k=e=o=1,v=t.search`\n`+2,-1,-v].some(h=>i=({"|":v-1,"_":1,"/":v,"\\":v})[d=t[r=l=t.search`x`+h]]),[...t].map(_=>o+=(k&=t[l-=i]==d)+(e&=t[r+=i]==d)),o);

[
G( 
 "| \n" +
 "| \n" +
 "|x\n" +
 "| \n" +
 "| \n"
),

G(
"|\\   \n" +
"| \\x \n" +
"|  \\ \n" +
"|___\\\n"
),

G(
"Diagram of a Wobbly Line:\n" +
"IRRELEVANTTEXT____       \n" +
"____     ____\/           \n" +
"    \___\/ X ;)           \n" +    
"      x                  \n"
),

G(
" ______________ \n"  +
"/ ____________ \\\n" +
"|/ __________ \\|\n" +
"||/ ________ \\||\n" + 
"|||/ ______ \\|||\n" +
"||||/      \\||||\n" +
"|||||/  x  |||||\n"  +
"|||||\_____\/||||\n" +
"||||\_______\/|||\n" +
"|||\_________\/||\n" +
"||\___________\/|\n" +
" \_____________\/\n"
)
]

नमूना आउटपुट (यदि आप इसे Google Chrome डेवलपर टूल कंसोल में चलाते हैं)

[५, ४, ३, ५]

Answer 2

पायथन 3, 428 408 385 378 बाइट्स

काम कर रहे हैं, लेकिन गोल्फ होने की एक टन क्षमता है। मैं थोड़ी रूखी हूं।

आयत इनपुट को आयत बनाने के लिए रिक्त स्थान के साथ गद्देदार किया जाता है।

संपादित करें: 23 बाइट बचत के लिए @Artyer को धन्यवाद!

EDIT2: वाह मैं पूरी तरह से 6 बाइट बचत से चूक गया। एक बराबर जाँच के पक्षों की अदला-बदली करके 1 और बचा।

*i,=map(list,input().split('\n'))
r=c=s=q=e=w=0
o=lambda y,x:len(i[0])>x>=0<=y<len(i)
d='\/_|'
for l in i:
 if'x'in l:r=i.index(l);c=l.index('x')
for a,b in(1,0),(0,1),(-1,0),(0,-1):
 y,x=r+a,c+b;f=o(y,x)and i[y][x]
 if f in d:s=f;w=d.index(f);q,e=y,x
k=lambda y,x,g=[1,1,0,1][w],v=[1,-1,1,0][w]:o(y,x)and s==i[y][x]and(exec('i[y][x]=0')or 1+k(y+g,x+v)+k(y-g,x-v))
print(k(q,e))

स्पष्टीकरण के साथ विस्तारित संस्करण:

inputtt='''  ______________.
 / ____________ \
 |/ __________ \|
 ||/ ________ \||
 |||/ ______ \|||
 ||||/      \||||
 |||||/  x  |||||
 |||||\_____/||||
 ||||\_______/|||
 |||\_________/||
 ||\___________/|
  \_____________/'''

# First, we get the input from STDIN and make it
# into a doubly-nested array

*input_text,=map(list,inputtt.split('\n'))

# A pretty cool Python trick to assign 0 to
# mulitple variables at once.

row=col=line_letter=line_row=line_col=line_char_index=0

# A function to check if a certian row and col is
# in bounds or not. Uses python's comparator chaining

in_bounds=lambda y,x:len(input_text[0])>x>=0<=y<len(input_text)

# A string to store all the line characters.
chars='\/_|'

# Search for the x
for line in input_text:

 # If this line contains the x...
 if'x'in line:

     # Mark the row and column
     row=input_text.index(line);col=line.index('x')

# For each direction...
for down,right in(1,0),(0,1),(-1,0),(0,-1):

 # Move in that direction
 y,x=row+down,col+right

 # If the position is in bounds, mark the char at that position
 line_found=in_bounds(y,x)and input_text[y][x]

 # If the char is a line char, set all the variables saying we found it
 if line_found in chars:
  line_letter=line_found
  line_char_index=chars.index(line_found)
  line_row,line_col=y,x

recur=lambda y,x,\
       # Find which directions we are supposed to recur in based on the line char
       g=[1,1,0,1][line_char_index],v=[1,-1,1,0][line_char_index]:\
       # If the char is in bounds and we are still on the line...
       in_bounds(y,x)and input_text[y][x]==line_letter and\
       # Set the spot to a 0, so we won't go back, increment,
       # and recur in both directions
       (exec('i[y][x]=0')or 1+recur(y+g,x+v)+recur(y-g,x-v))

# Finally, print the answer
print(recur(line_row,line_col))

Comments

मैंने pastebin.com/zKENQUeR पर कुछ गोल्फ सुझाव दिए हैं । यदि आप चाहते हैं (कुल: -18 बाइट्स) का उपयोग करने के लिए स्वतंत्र महसूस करें। इसके अलावा, आप <!-- language-all: lang-py -->सिंटैक्स हाइलाइटिंग के लिए जोड़ना चाह सकते हैं ।

— Artyer

@Artyer धन्यवाद! मैं उन सबसे नहीं करने के लिए बेवकूफ था, लेकिन मुझे गैर-भागने वाले बैकलैश के बारे में कोई पता नहीं था। मैं वर्तमान में मोबाइल पर हूं, लेकिन बाद में आपके सुझावों को शामिल करना सुनिश्चित करूंगा!

— ब्लू

ओह, और एक और: पहली पंक्ति के लिए *i,=map(list,inputtt.split('\n'))( एक नक्शे के बजाय एक सूची *i,बनाता iहै) (-6 अधिक बाइट्स)

— 22

वाह ... अपनी संपूर्णता में गोल्फ।

— आउटगोल्फ

Answer 3

लुआ, 480 बाइट्स

Lua, Verbose Language होने के नाते, यह पायथन जवाब को हरा नहीं करता है। लेकिन इसकी जरूरत नहीं है।

a=...s={}for _ in a:gmatch"[^\n]*"do s[#s+1]={}for S in _:gmatch"."do if S=="x"then x=#s[#s]+1y=#s end s[#s][#s[#s]+1]=S end end c="\\/_|"X={-1,1,1,0}Y={-1,-1,0,-1}for _,d in pairs({{x-1,y},{x,y-1},{x+1,y},{x,y+1}})do K=d[2]k=d[1]h=s[K]w=h and h[k]C=w and c:find(w)if C then n=1 j=k J=K while true do j=j+X[C]J=J+Y[C]if s[J]and s[J][j]==w then n=n+1 else break end end j=k J=K while true do j=j-X[C]J=J-Y[C]if s[J]and s[J][j]==w then n=n+1 else break end end print(n)break end end

मेरे संदर्भ कार्यान्वयन के समान, लेकिन गोल्फिंग में एक वास्तविक शॉट लेता है, और कुछ चीजों को पहले की तुलना में थोड़ा अधिक स्मार्ट बनाता है। अभी भी शायद थोड़ा बेहतर गोल्फ हो सकता है।

टिप्पणियों के साथ।

a=... -- Take the input from the command line.
s={}  -- Store the string as a 2D Table, instead of a multiline string.
for _ in a:gmatch"[^\n]*"do -- For each new row.
    s[#s+1] = {}            -- Make a new sub-table. This is our line.
    for S in _:gmatch"."do  -- For every character.
        if S=="x"then x=#s[#s]+1y=#s end -- If it's an x, mark down the X and Y position of it.
        s[#s][#s[#s]+1]=S                -- Push the character. This could probably be better golfed.
    end
end
c="\\/_|"   -- The ascii line characters.
X={-1,1,1,0}    -- Their X Directionals.
Y={-1,-1,0,-1}  -- Their Y Directionals.
                -- These are inversed to get their opposite direction.
for _,d in pairs({{x-1,y},{x,y-1},{x+1,y},{x,y+1}}) do -- For each up down left and right.
    K=d[2]  -- K = y
    k=d[1]  -- k = x
    h=s[K]  -- h = the yth row
    w=h and h[k]    -- w = the xth character of the yth row, if the yth row exists.
    C=w and c:find(w) -- C = the id of the ascii line character, if w existed.
    if C then
        n=1 -- n = the length of the line.
        j=k -- Temp x
        J=K -- Temp y
        while true do
            j=j+X[C] -- Increment j by the directional of the ascii.
            J=J+Y[C] -- Ditto. for J
            if s[J]and s[J][j]==w then -- if it's still the same.
                n=n+1 -- Add 1 to the length.
            else
                break -- Or stop.
            end
        end
        j=k -- Re-assign the temps as their original.
        J=K
        while true do
            j=j-X[C] -- Search in the other direction.
            J=J-Y[C]
            if s[J]and s[J][j]==w then
                n=n+1
            else
                break
            end
        end
        print(n) -- Print the length.
        break
    end
end

Answer 4

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

मान लें कि आयत बनाने के लिए रिक्त स्थान के साथ इनपुट है।

s=>(o=>{s.replace(/[_|\\/]/g,(c,p)=>[o,-o,1,-1].map(d=>s[p+d]=='x'?[q,k]=[p,c]:c));for(n=z=k>'_'?o:k>'\\'?-1:k>'/'?o-1:o+1;s[q+=z]==k||z<0&&(n=-1,z=-z);)n++})(~s.search`
`)||n

कम गोल्फ वाला

s=>{
  o = ~s.search`\n`; // offset between rows (negated)
  // look for a line character near an 'x'
  s.replace(/[_|\\/]/g, 
     (c,p)=> // for each line char 'c' in position 'p'
     [o,-o,1,-1].map(d=>s[p+d]=='x' // found a near 'x' ?
                        ?[q,k]=[p,c] // remember char and position
                        :c)
  );
  n=0;
  z=k>'_'?o:k>'\\'?-1:k>'/'?o-1:o+1; // offset to prev char of line
  while (s[q+=z]==k // move to left/top first
         || z<0 && (n=0,z=-z) // at left/top, go back and start counting
        )
    n++;
  return n-1;
}

स्पष्टता के लिए रिक्त स्थान के बजाय टेस्ट डॉट्स

f=
s=>(o=>{s.replace(/[_|\\/]/g,(c,p)=>[o,-o,1,-1].map(d=>s[p+d]=='x'?[q,k]=[p,c]:c));for(n=z=k>'_'?o:k>'\\'?-1:k>'/'?o-1:o+1;s[q+=z]==k||z<0&&(n=-1,z=-z);)n++})(~s.search`
`)||n

out=x=>O.textContent+=x

;["|.\n|.\n|x\n|.\n|.\n", "|\\...\n|.\\x.\n|..\\.\n|___\\\n"
,"Diagram of a Wobbly Line:\nIRRELEVANTTEXT...........\n____.....____/...........\n....\\___/.X.;)...........\n......x..................\n"
,"./ ____________ \\\n.|/ __________ \|\n.||/ ________ \\||\n.|||/ ______ \\|||\n.||||/      \\||||\n.|||||/  x  |||||\n.|||||\\_____/||||\n.||||\\_______/|||\n.|||\\_________/||\n.||\\___________/|\n. \\_____________/\n"].forEach(s=>out(s+f(s)+'\n\n'))

<pre id=O></pre>