क्या बीम टकराएगा?

31

एक लेजर चार ऑर्थोगोनल दिशाओं में से एक में एक सीधी बीम को गोली मारता है, जिससे संकेत मिलता है <>^v। यह निर्धारित करें कि क्या यह Oआयताकार ग्रिड पर लक्ष्य से टकराएगा।

इनमें से प्रत्येक हिट होगा (ट्रू):

.....
...O.
.....
...^.
.....

>O.
...

v....
O....

...........
...........
O.........<
...........

ये याद करेंगे (गलत):

......
......
.^..O.

......
.....>
O.....
......
......


.O.
...
.v.

.....<.
..O....

इनपुट: एक आयताकार ग्रिड ., जिसका आकार कम से कम 2x2 है, एक लक्ष्य Oऔर एक लेजर जिसमें से एक है <>^v। लाइनें स्ट्रिंग की एक सूची हो सकती हैं, 2 डी सरणी या वर्णों की नेस्टेड सूची, या एक नई अनुगामी-अलग स्ट्रिंग के साथ एक वैकल्पिक अनुगामी न्यूलाइन हो सकती है।

आउटपुट : यदि लेजर बीम लक्ष्य से टकराता है, और यदि वह चूकता है तो एक सुसंगत सत्य मान।

मैं उन सबमिशनों पर विचार करूँगा जो नियमित एक्सप्रेशन (या बिल्ट-इन पैटर्न-बेस्ड स्ट्रिंग मैचिंग) को एक अलग श्रेणी के रूप में उपयोग नहीं करते हैं। यदि आप (no regex)भाषा का नाम रखते हैं, तो आपका उत्तर लीडरबोर्ड में अलग से दिखाई देगा।

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

code-golf  ascii-art 
— XNOR
स्रोत
8
— विजुअलमेल
6
मैं उम्मीद कर रहा था कि आप के साथ दर्पण शामिल होंगे /और \ । शायद एक और सवाल के लिए ...
— १
2
@ मेगो ... जो इस चुनौती को बहुत सरल बनाता है और बहुत अलग दृष्टिकोणों की अनुमति देता है।
— मार्टिन एंडर
2
@ मैं असहमत हूँ; उस तर्क से, एक ही समय में सादे हैलो विश्व चुनौती दर्जनों अन्य चुनौतियों की नकल है। वैसे भी, मुझे उस शक्ति के बारे में सूचित करने के लिए धन्यवाद जो मुझे अब कोड गोल्फ चुनौतियों को बंद / फिर से खोलना है, मुझे इसके बारे में पता नहीं था।
— aditsu
5
@Mego हालांकि यह सवाल दूसरे का एक विशेष मामला है, मुझे विश्वास नहीं है कि यह एक धोखा है क्योंकि उत्तर पूरी तरह से अलग दृष्टिकोण का उपयोग करते हैं। उस सवाल पर, वे सभी उस बीम की गणना करते हैं जो बीम लेता है। पोर्टल पथ को कहीं से भी ले जा सकते हैं जो शॉर्टकट की अनुमति नहीं देता है, और रिफ्लेक्टर को संभालने के लिए मुश्किल है। इसके बजाय यहां जवाब ज्यादातर इनपुट स्ट्रिंग की कुछ संपत्ति की जांच या मिलान करते हैं। ज़रूर, आप दूसरी चुनौती से एक पथ-अनुरेखण उत्तर को कॉपी कर सकते हैं और अतिरिक्त बिट्स को हटा सकते हैं, लेकिन यह विधि ओवरकिल है और एक अनावश्यक रूप से लंबा समाधान देता है।
— xnor

जवाबों:

27

घोंघे , 19 बाइट्स

\>|\<l|\^u|\vd).,\O

इस के लिए कल्पना को यथासंभव शाब्दिक रूप से लागू किया जा सकता है, किसी सोच की आवश्यकता नहीं है।

— feersum
स्रोत
6
क्या आप इस बात का स्पष्टीकरण जोड़ सकते हैं कि यह कैसे काम करता है?
— निधि मोनिका का मुकदमा
5
@QPaysTaxes जब तक feersum इसके आसपास हो जाता है, उम्मीद है कि यह मदद करेगा: घोंघे एक 2 डी पैटर्न मिलान भाषा है। udlrघोंघा की दिशा को ऊपर / नीचे / बाएँ / दाएँ सेट करें। |यह काम करता है जैसे कि यह नियमित रेगेक्स में करता है, और )इसके लिए मेल खाता खुला कोष्ठक की जरूरत नहीं है। तो कोड सुंदर सीधे "किसी एक को खोजने v<>^और दिशा को उचित रूप से सेट करने के लिए अनुवाद करता है, फिर उस दिशा में एक O खोजने का प्रयास करें।"
— फ्राईमई इगमैन
हाँ, एगमैन ने क्या कहा। केवल दूसरी चीज यह है कि रेगेक्स की ,तरह है *।
— feersum
13

रेटिना, 56 52 42 38 31 30 बाइट्स

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

O.*<|>.*O|[vO](.*¶)[^O]*[O^]\1

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

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

व्याख्या

यह तीन भागों में काम करता है:

  • मेल मिलाना >
  • मेल मिलाना <
  • मिलान ^और vइसका कारण यह है कि तर्क ^और vवास्तव में एक ही हैं, बस वर्ण।

सत्यापित किया जा रहा <

यह सरल है:

O.*<

यह मेल खाता है O, इसके बाद वैकल्पिक रूप से नॉन-न्यूलाइन वर्ण, फिर ए<

सत्यापित किया जा रहा >

यह पिछले रास्ते को छोड़कर अन्य तरीकों के समान ही है। पहले एक >मिलान किया जाता है, फिरO

मान्य ^औरv

यह गोल्फ के लिए मुश्किल था और इनपुट के विज्ञापन को हमेशा वैध माना जाता था। सबसे पहले, हम मिलान करते हैं कि यह है vया नहीं O:

[vO]

यदि यह एक है ^, तो पहला वर्ण जो सामने आया है वह होना चाहिए O। तो, यह मैच के लिए पहला चरित्र है। आगे हम .नई सीमा तक निम्नलिखित s की मात्रा की गणना करते हैं :

(.*\n)

अगला, यह दो भागों में जा सकता है, मैं पहले कवर करूँगा:

तो पहले, हम निम्नलिखित Oका उपयोग करके मिलान करते हैं:

[^O]*O

यह वैकल्पिक रूप से सभी गैर- Oवर्णों से मेल खाता है जब तक Oकि सामना नहीं किया जाता है, अगर यह सफल होता है, तो यह जारी रहता है ... यदि नहीं, तो निम्न होता है ...

अब, यह ^उपयोग करने का प्रयास करता है :

[^^]*\^

^regex में एक विशेष चरित्र है, इसलिए इसे भागने की जरूरत है। [^^]सभी वर्णों को छोड़कर ^, यह उपरोक्त के समान कार्य करता है, यदि यह सफल होता है, तो निम्नलिखित होता है ...

तो अब, उपरोक्त में से एक ने सफलतापूर्वक मिलान किया है, \1और देखता है कि क्या कब्जा समूह पहले से था (.*\n), इस कैप्चर समूह ने पहले या .बाद में या तो उसके बाद एस की मात्रा संग्रहीत की थी , इसलिए अब यह जांचें कि क्या डॉट्स की मात्रा वही।vO\1

— Downgoat
स्रोत
के बजाय का उपयोग करके आप एक बाइट बचा सकते हैं \n(रेटिना आईएसओ 8859-1 में स्रोत कोड को संभाल सकते हैं।)
— मार्टिन एंडर
@ मार्टिनबटनर ने सोचा कि प्रतिस्थापन में केवल \ n था, टिप के लिए धन्यवाद!
— डाउनगेट
नहीं यह स्रोत कोड में कहीं भी काम करता है। फ़ाइल को लाइनों में विभाजित करने के बाद , किसी भी आगे पार्सिंग करने से पहले, रेटिना की पहली चीज़ हर जगह बदल जाती है।
— मार्टिन एंडर
9

जावा (कोई रेगेक्स), 413 412 246 242 212 211 209 198 बाइट्स

जावा का उपयोग करते हुए गोल्फ की चुनौतियों में प्रतिस्पर्धा करने से साइकिल पर फॉर्मूला 1 की दौड़ में भाग लेने की तुलना में कम समझदारी है, लेकिन मैं हमेशा ऐसा नहीं कर रहा हूं जिससे कोई मतलब हो।

यहाँ मेरा बहुत लंबा जावा समाधान गोल्फ संस्करण है

boolean l(char[][]w){int[]t={},l={};for(int y=0;y<w.length;y++)for(int x=0;x<w[0].length;x++){if(w[y][x]=='O')t=new int[]{x,y};if(w[y][x]=='<')l=new int[]{x,y,1};if(w[y][x]=='>')l=new int[]{x,y,2};if(w[y][x]=='v')l=new int[]{x,y,3};if(w[y][x]=='^')l=new int[]{x,y,4};};return(l[2]==1&&l[1]==t[1]&&l[0]>t[0])||(l[2]==2&&l[1]==t[1]&&l[0]<t[0])||(l[2]==3&&l[0]==t[0]&&l[1]<t[1])||(l[2]==4&&l[0]==t[0]&&l[1]>t[1]);}

और अपुष्ट

boolean l(char[][] w) {
    int[] t = {}, l = {};
    for (int y = 0; y < w.length; y++)
        for (int x = 0; x < w[0].length; x++) {
            if (w[y][x] == 'O')
                t = new int[] { x, y };
            if (w[y][x] == '<')
                l = new int[] { x, y, 1 };
            if (w[y][x] == '>')
                l = new int[] { x, y, 2 };
            if (w[y][x] == 'v')
                l = new int[] { x, y, 3 };
            if (w[y][x] == '^')
                l = new int[] { x, y, 4 };
        }
    ;
    return (l[2] == 1 && l[1] == t[1] && l[0] > t[0])
            || (l[2] == 2 && l[1] == t[1] && l[0] < t[0])
            || (l[2] == 3 && l[0] == t[0] && l[1] < t[1])
            || (l[2] == 4 && l[0] == t[0] && l[1] > t[1]);
}

लगता है कि मेरी पूरी अवधारणा गलत थी, यहाँ मेरा छोटा समाधान है

boolean z(char[][]w){int x=0,y=0,i=0,a=w.length,b=w[0].length;for(;w[y][x]!=79;)if(++y==a){y=0;x++;}for(;i<(a<b?b:a);)if(i<b&w[y][i]==(i<x?62:60)|i<a&w[i][x]==(i++<y?'v':94))return 1<2;return 1>2;}

और अनप्लग्ड संस्करण

oolean z(char[][] w) {
        int x = 0, y = 0, i = 0, a = w.length, b = w[0].length;
        for (; w[y][x] != 79;)
            if (++y == a) {
                y = 0;
                x++;
            }
        for (; i < (a < b ? b : a);)
            if (i < b & w[y][i] == (i < x ? 62 : 60) | i < a
                    & w[i][x] == (i++ < y ? 'v' : 94))
                return 1 < 2;
        return 1 > 2;
    }

EDIT I ने 'O' की तलाश के लिए कोड को फिर से लिखा है, अब इसमें एकल लूप बहुत छोटा है, और मैंने कुछ अक्षरों को उनके अस्की मूल्यों के साथ बदलने के लिए @Frozn सुझाव का उपयोग किया।

इसके अलावा, एक और 30 बाइट्स धूल को काटता है।

@Frozn से एक और सुझाव, और हम पायथन समाधान के करीब युगल बाइट्स हैं

एक और फिर से लिखना एक लूप को छोड़ देता है, और दो को जोड़ देता है यदि कथन

— user902383
स्रोत
1
+1 आप बीच की जगह को हटा सकते हैं returnऔर (बाइट को बचा सकते हैं, हालाँकि। आपके रिटर्न मान को कोष्ठक (या स्ट्रिंग्स के लिए उद्धरण) के अंदर स्थान आवश्यक नहीं है। जावा कोड-गोल्फ टिप्स से स्रोत।
— केविन क्रूज़सेन
@KevinCruijssen ज्यादा बचत नहीं कर रहा है, लेकिन धन्यवाद :)
— user902383
हर छोटा सा (या मुझे बाइट कहना चाहिए) मुझे अनुमान लगाने में मदद करता है। ;) इसके अलावा, मुझे नहीं लगता कि जावा कभी भी एक कोड-गोल्फ चुनौती जीतेगा। मैं अभी भी जावा में कोड-गोल्फ चुनौतियों को करना पसंद करता हूं, खासकर जब से मैं वर्तमान में काम में जावा के साथ काम कर रहा हूं।
— केविन क्रूज़सेन
आप उनके ASCII मूल्य द्वारा वर्ण की जगह ले सकता: 'O' = 79, '>' = 62, '<' = 60, '^' = 94। 'V' के लिए यह 118 है, लेकिन यह कोड को छोटा नहीं करता है।
— फ्रोज़न
@Frozn केविन के रूप में, हर बाइट मायने रखता है।
— user902383
7

MATL (कोई रेगेक्स), 26 25 24 22 बाइट्स

'>v<^'XJymfX!tZpYswJm)

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

सभी परीक्षण मामलों के लिए संशोधित संस्करण

व्याख्या

        % Implicitly grab input
'>v<^'  % String literal indicating the direction chars
XJ      % Store in the J clipboard
y       % Copy the input from the bottom of the stack
m       % Check to see which of the direction chars is in the input. The
        % result is a 1 x 4 logical array with a 1 for the found direction char
f       % Get the 1-based index into '>v<^' of this character
X!      % Rotate the input board 90 degrees N times where N is the index. This
        % Way we rotate the board so that, regardless of the direction char,
        % the direction char should always be BELOW the target in the same column
t       % Duplicate
Zp      % Determine if any elements are prime ('O' is the only prime)
Ys      % Compute the cumulative sum of each column
w       % Flip the top two stack elements
J       % Grab '>v<^' from clipboard J
m       % Create a logical matrix the size of the input where it is 1 where
        % the direction char is and 0 otherwise
)       % Use this to index into the output of the cumulative sum. If the 
        % direction char is below 'O' in a column, this will yield a 1 and 0 otherwise
        % Implicitly display the result
— Suever
स्रोत
@LuisMendo अब यह पता लगाने के लिए कि कैसे छुटकारा पाने के लिएJ
— सूअर
मैं MATL नहीं जानता, इसलिए यह एक मूर्खतापूर्ण प्रश्न हो सकता है, लेकिन 0 प्राइम क्यों है?
— नील
3
@ नील यह पत्र है 'O', संख्या नहीं 0। पत्र के लिए ASCII कोड 'O'है79
— लुइस मेंडो
उह, मुझे लगता है कि अगर आप इसके बजाय विषम संख्या की तलाश कर रहे थे, तो मुझे अभी भी मूर्ख बनाया गया होगा।
— नील
5

सीजेम (कोई रेगेक्स), 25

पहले के संस्करण गलत थे, अब इसके लिए करना होगा:

q~_z]{'.-HbI%}f%[HF].&~+,

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

स्पष्टीकरण:

q~         read and evaluate the input (given as an array of strings)
_z         copy and transpose
]          put the original grid and transposed grid in an array
{…}f%      map the block to each grid (applying it to each string in each grid)
  '.-      remove all dots (obtaining a string of 0 to 2 chars)
  Hb       convert to base H=17, e.g. ">O" -> 62*17+79=1133
  I%       calculate modulo I=18
[HF]       make an array [17 15]
.&         set-intersect the first array (mapped grid) with 17 and 2nd one with 15
~+         dump and concatenate the results
,          get the array length

मैंने "अच्छे" और "बुरे" तारों के बीच अंतर करने के लिए कुछ गणितीय फ़ार्मुलों की कोशिश की, और प्रत्येक प्रकार के सूत्र के लिए मैंने विभिन्न संख्याओं में प्लगिंग की कोशिश की। मैं ऊपर के साथ समाप्त हो गया HbI%।

मूल ग्रिड के लिए "अच्छे" तार "> O" और "O <" हैं और वे परिणाम देते हैं 17
"अच्छे" तार ट्रांसपोज़्ड ग्रिड के लिए हैं "vO" और "O ^" और वे परिणाम 15
"खराब" देते हैं दोनों ग्रिड के लिए तार हैं: ">", "<", "^", "v", "O", "", "O>", "Ov", "<O", "^ O" और वे देते हैं परिणाम 8, 6, 4, 10, 7, 0, 1, 3, 1, 3

— aditsu
स्रोत
3

पायथन 3 (रेगेक्स नहीं), 184 बाइट्स।

हैकिंग के लिए हुर्रे!

def f(a,o=0,d={},q=''):
 for r in a:
  i=0
  for c in r:d[c]=o,i;i+=1;q=(c,q)[c in'O.']
  o+=1
 z,y=d['O'];e,j=d[q];return eval("z%se and y%sj"%(('><'[q<'v'],'=='),('==',q))[q in'><'])
— मॉर्गन थ्रैप
स्रोत
3

TSQL (sqlserver 2012) (कोई रेगेक्स), 358 बाइट्स

DECLARE @ varchar(1000)=
'......'+ CHAR(13)+CHAR(10)+
'......'+ CHAR(13)+CHAR(10)+
'...0..'+ CHAR(13)+CHAR(10)+
'...^..'+ CHAR(13)+CHAR(10)
;

WITH C as(SELECT
number n,SUBSTRING(@,number,1)a,1+min(IIF(SUBSTRING(@,number,1)=char(13),number,99))over()m
FROM master..spt_values
WHERE'P'=type and
SUBSTRING(@,number,1)in('>','<','^','v','0',char(13)))SELECT
IIF(c.n%c.m=d.n%c.m and c.a+d.a in('0^','v0')or
c.n/c.m=d.n/c.m and c.a+d.a in('>0','0<'),1,0)FROM c,c d
WHERE c.n<d.n and char(13)not in(c.a,d.a)

ऑनलाइन संस्करण को इसे निष्पादित करने के लिए मजबूर करने के लिए घोषणा में फंकी लाइनकेंज का उपयोग करना पड़ा (इनपुट चर के लिए मान असाइन करना वैसे भी लंबाई गणना को प्रभावित नहीं करता है)

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

— t-clausen.dk
स्रोत
2

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

s=>s.match(`>.*O|O.*<|(?=v)([^]{${l=s.search`\n`+1}})+O|(?=O)([^]{${l}})+\\^`)

पाठ्यक्रम का Regexp। रूबी के उत्तर में सिद्धांत के समान निकला।

— नील
स्रोत
2

रूबी, 71 55 54 बाइट्स

रेगेक्स समाधान, जिसका अर्थ है कि यह शायद रेटिना या पर्ल द्वारा आसानी से पीटा जा रहा है।

यदि कोई मेल है तो एक इंडेक्स नंबर (सत्य) लौटाता है।

अब @Downgoat रेटिना जवाब के लिए एक समान चाल के साथ, एक ही समय में नीचे और ऊपर बीम के लिए मिलान।

->m{m=~/>\.*O|O\.*<|(?=[vO])(.{#{??+m=~/\n/}})+[O^]/m}
— मूल्य स्याही
स्रोत
2

जावास्क्रिप्ट (ईएस 6) (कोई रेगेक्स), 126 बाइट्स

s=>([n,o,l,r,u,d]=[..."\nO<>^"].map(c=>1+s.indexOf(c)),l>o&l-o<n&l%n>o%n||r&&r<o&o-r<n&r%n<o%n||u>o&u%n==o%n||d&&d<o&d%n==o%n)

जहां \nशाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है।

— नील
स्रोत
2

क्लोजर (रेगेक्स नहीं), 293 बाइट्स

(defn z[f](let[v(sort(keep-indexed(fn[i v](if(some #{v}[\v\>\<\^\O])[(if(= v\O)\& v)i]))f))l(+(.indexOf f"\n")1)d((nth v 1)0)q((nth v 1)1)p((nth v 0)1)r(=(quot p l)(quot q l))i(> q p)](cond(= d\^)(and i(=(mod(- q p)l)0))(= d\v)(and(not i)(=(mod(- p q)l)0))(= d\>)(and(not i)r):else(and i r))))

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

आप इसे यहाँ ट्राई कर सकते हैं https://ideone.com/m4f2ra

— cliffroot
स्रोत
2

पायथन (कोई रेगेक्स), 105 बाइट्स

def f(s):t=s.strip('.\n');return not['\n'in t,len(t)%(s.find('\n')+1)!=1,1]['>O<vO^'.find(t[0]+t[-1])//3]

सही या गलत रिटर्न

सबसे पहले, स्ट्रिप्स '।' और '\ n' सिरों से इसलिए कि '0 <> v ^' ब्याज के अक्षर, पहले और अंतिम अक्षर हैं।

'>O<vO^'.find(t[0]+t[-1])//3- जांचता है कि क्या अक्षर एक संभावित वैध व्यवस्था है। '> O ’या' O <’ के लिए 0 से O vO ’या ^ O ^’ के लिए, और -1 के लिए किसी भी चीज़ का मूल्यांकन करता है।

'\n'in t- जाँचता है कि क्या वर्ण अलग-अलग पंक्तियों में हैं,
len(t)%(s.find('\n')+1)!=1- जाँचता है कि क्या वे अलग-अलग कॉलम में हैं, और
1- डिफ़ॉल्ट है

notउलट परिणाम सूची से चयनित है, तो returnअभिव्यक्ति के बराबर है:

t[0]+t[-1] in '>0<' and '\n' not in t or t[0]+t[-1] in 'vO^' and len(t)%(s.find('\n')+1)==1
— RootTwo
स्रोत
2

जूलिया (कोई रेगेक्स), 98

a->(c=rotr90(a,findlast("i1Q/",sum(a-46)));
    f(n)=find(any(c.!='.',n));b=c[f(2),f(1)];
    (b'*b)[1]==97)

वर्णों की एक सरणी पर कार्य करना, रोटेशन को सामान्य करना, रेंज इंडेक्सिंग द्वारा केवल डॉट्स युक्त पंक्तियों और स्तंभों को हटाना और अंत में मैट्रिक्स के गुणन का उपयोग करके शेष बी एक स्तंभ या पंक्ति वेक्टर होने पर खाते में 'ओ' के स्थान की जांच करना।

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

— mschauer
स्रोत
1

अजगर 2 (कोई रेगेक्स), 268 बाइट्स

import numpy
def q(i):
 s=numpy.asmatrix(i)
 for n in s:
  n=n.tolist()[0]
  try:
   a=n.index("0")
   if n.index(">")<a or n.index("<")>a:return 1
  except:0
 for n in range(len(i)):
  c=[x[0] for x in s[:,n].tolist()]
  try:
   a=c.index("0")
   if c.index("v")<a or c.index("^")>a:return 1
  except:0
 return 0

फ़ंक्शन द्वारा लौटाए गए सत्य और झूठे मूल्य क्रमशः 1 और 0 हैं।

मुझे अभी तक गोल्फ का मौका नहीं मिला है। ईमानदारी से, मैं इस एक के लिए बहुत उम्मीद नहीं कर रहा हूँ ...

किसी भी सुझाव के लिए बहुत आभार होगा!

— डैनियल
स्रोत
1

सी # (नो रेगेक्स), 282 बाइट्स

bool F(char[,]b){int k=0,l=1,m=1,n=0,o=0;for(int x=0;x<b.GetLength(0);x++)for(int y=0;y<b.GetLength(1);y++){char i=b[x,y];if(i=='O'){k=x;l=y;}if(new[]{'<','>','^','v'}.Contains(i)){m=x;n=y;o=i;}}return(o==60&&k==m&&l<n)||(o==62&&k==m&&l>n)||(o==94&&l==n&&k<m)||(o==118&&l==n&&k>m);}

जावा संस्करण की तरह काम करता है लेकिन ट्रांसप्लैड और कम हो जाता है

विस्तारित (स्पष्टीकरण शामिल):

bool F(char[,] b)
{
    // declare variables for goal x, goal y, laser x, laser y, and laser direction respectively (laser direction is char code for directions)
    int k = 0, l = 0, m = 0, n = 0, o = 0;
    // go through each cell
    for (int x = 0; x < b.GetLength(0); x++)
    {
        for (int y = 0; y < b.GetLength(1); y++)
        {
            // get cell contents
            char i = b[x, y];
            // set goal position if goal
            if (i == 'O')
            {
                k = x;
                l = y;
            }
            // set laser position and direction if laser
            if (new[]{ '<', '>', '^', 'v' }.Contains(i))
            {
                m = x;
                n = y;
                o = i;
            }
        }
    }
    // check everything is on the same line and in right direction
    return (o == 60 && k == m && l < n) ||
           (o == 62 && k == m && l > n) ||
           (o == 94 && l == n && k < m) ||
           (o == 118 && l == n && k > m);
}
— RedLaser
स्रोत
0

सी (एएनएसआई) (कोई रेगेक्स), 237 बाइट्स

#define l b[1][i]
main(i,b,c,d,x,y,z,p)char **b;{for(y=z=i=0,x=1;z<2&&(l==10?x=0,++y:1);i++,x++)if(l>46){if(l!=79)p=l;if(!z++)c=x,d=y;}i--;x--;z=(c==x)*((p=='v')*(l==79)+(p==94)*(l==p))+(d==y)*((p==60)*(l==p)+(p==62)*(l==79));return z;}

विस्तारित:

#define l b[1][i]
main(i,b,c,d,x,y,z,p)char **b;{
    for(y=z=i=0,x=1;z<2&&(l==10?x=0,++y:1);i++,x++)
        if(l>46){if(l!=79)p=l;if(!z++)c=x,d=y;}
    i--;x--;
    z=(c==x)*((p=='v')*(l==79)+(p==94)*(l==p))+(d==y)*((p==60)*(l==p)+(p==62)*(l==79));
    printf("%i\n",z);
    return z;
}

मुझे लगता है कि मैंने जावा या सी # कार्यान्वयन की तुलना में यहां एक अलग दृष्टिकोण अपनाया। मुझे 'ओ' और तीर ((सी, डी) और (एक्स, वाई)) के निर्देशांक मिले और फिर उनकी तुलना यह देखने के लिए की क्या तीर सही दिशा में इशारा कर रहा है।

0 झूठे और 1 अगर सच है तो लौटाता है

— dj0wns
स्रोत
0

ग्राइम v0.1 , 31 बाइट्स

n`\>.*a|a.*\<|\v/./*/a|a/./*/\^

बहुत दिलचस्प समाधान नहीं है। 1सत्य उदाहरणों के लिए, और 0झूठे लोगों के लिए प्रिंट । इसे ऑनलाइन आज़माएं!

व्याख्या

हम बस एक न्यूनतम आकार (n × 1 या 1 × n) पैटर्न के लिए इनपुट आयत को खोजते हैं जिसमें सही क्रम में लेजर और लक्ष्य होते हैं। n`झंडा दुभाषिया मैचों, जिनमें से हमेशा सबसे एक पर किया जाएगा की संख्या प्रिंट बनाता है। शेष पंक्ति में चार पैटर्न अलग-अलग होते हैं |-चट्रर्स, जिसका अर्थ है एक तार्किक या: एक आयत का मिलान होता है यदि यह पैटर्न में से एक से मेल खाता है। पैटर्न निम्नानुसार काम करते हैं:

\>.*a    Literal ">", horizontal row of any chars, one alphabetic char
a.*\<    One alphabetic char, horizontal row of any chars, literal "<"
\v/./*/a Literal "v", on top of vertical column of any chars, on top of one alphabetic char
a/./*/\^ One alphabetic char, on top of vertical column of any chars, on top of literal "^"
— Zgarb
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.