মরীচি কি আঘাত করবে?


31

একটি লেজার দ্বারা নির্দেশিত চারটি অর্থেগোনাল দিকের একটিতে একটি সরল মরীচি অঙ্কুরিত করে <>^v। এটি Oএকটি আয়তক্ষেত্রাকার গ্রিডে লক্ষ্যবস্তুতে আঘাত করবে কিনা তা নির্ধারণ করুন।

এগুলির প্রত্যেকটি হিট (সত্য):

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

>O.
...

v....
O....

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

এগুলি মিস করবে (মিথ্যা):

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

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


.O.
...
.v.

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

ইনপুট:. হুবহু একটি লক্ষ্য Oএবং একটিতে একটি লেজার সহ কমপক্ষে 2x2 আকারের একটি আয়তক্ষেত্রাকার গ্রিড <>^v। লাইনগুলি স্ট্রিংগুলির তালিকা, একটি 2 ডি অ্যারে বা অক্ষরগুলির নেস্টেড তালিকা বা .চ্ছিক ট্রেলিং নতুন লাইনের সাথে একক নিউলাইন-বিভাজিত স্ট্রিং হতে পারে।

আউটপুট : লেজার মরীচি লক্ষ্যটি হিট করলে একটি ধারাবাহিক সত্যবাদী মান এবং যদি এটি মিস হয় তবে একটি ধারাবাহিক মিথ্যা মান।

আমি এমন সাবমিশন বিবেচনা করব যা নিয়মিত প্রকাশ (বা বিল্ট-ইন প্যাটার্ন-ভিত্তিক স্ট্রিং ম্যাচিং) পৃথক বিভাগ হিসাবে ব্যবহার করে না। যদি আপনি (no regex)ভাষার নাম রাখেন তবে আপনার উত্তর আলাদাভাবে লিডারবোর্ডে উপস্থিত হবে।



6
আমি আশা করছিলাম আপনি /এবং এর সাথে আয়না অন্তর্ভুক্ত করবেন \ । অন্য কোনও প্রশ্নের জন্য হতে পারে ...
vsz

2
@ মেগো ... যা এই চ্যালেঞ্জটিকে অনেক সহজ করে তোলে এবং খুব আলাদা পদ্ধতির জন্য অনুমতি দেয়।
মার্টিন ইন্ডার

2
@ মেগো আমি একমত নই; সেই যুক্তি অনুসারে, প্লেইন হ্যালো ওয়ার্ল্ড চ্যালেঞ্জ একই সাথে কয়েক ডজন অন্যান্য চ্যালেঞ্জগুলির একটি সদৃশ। যাইহোক, এখন আমাকে কোড গল্ফ চ্যালেঞ্জগুলি বন্ধ / পুনরায় খুলতে হবে সে সম্পর্কে আমাকে অবহিত করার জন্য ধন্যবাদ, আমি সে সম্পর্কে অবগত ছিলাম না।
অ্যাডিটসু

5
@ মেগো যদিও এই প্রশ্নটি অন্য একটির একটি বিশেষ ঘটনা, তবে আমি এটিকে একটি ছাপ হিসাবে বিশ্বাস করি না কারণ উত্তরগুলি সম্পূর্ণ ভিন্ন পদ্ধতির ব্যবহার করে। এই প্রশ্নে, তারা সকলেই মরীচিটি যে পথে নেয় তার গণনা করে। পোর্টালগুলি যে কোনও জায়গা থেকে যে কোনও জায়গায় পাথ সরিয়ে নিতে পারে যা শর্টকাটের অনুমতি দেয় বলে মনে হয় না এবং প্রতিচ্ছবিগুলি হ্যান্ডেল করার পক্ষে কৌতুকপূর্ণ। পরিবর্তে এখানে উত্তরগুলি বেশিরভাগ ইনপুট স্ট্রিংয়ের কিছু সম্পত্তি চেক বা মিলায়। অবশ্যই, আপনি অন্য চ্যালেঞ্জ থেকে একটি পথের সন্ধানের উত্তরটি অনুলিপি করতে পারেন এবং অতিরিক্ত বিটগুলি সরিয়ে ফেলতে পারেন, তবে এই পদ্ধতিটি অত্যধিক কিল এবং অকারণে দীর্ঘ সমাধান দেয়।
xnor

উত্তর:


27

শামুক , 19 বাইট

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

এটির জন্য অনুমানটি যথাসম্ভব আক্ষরিকভাবে প্রয়োগ করা যেতে পারে, কোনও চিন্তাভাবনার প্রয়োজন নেই।


6
এটি কীভাবে কাজ করে তার একটি ব্যাখ্যা আপনি যুক্ত করতে পারেন?
ফান্ড মনিকার লসুইট

5
@ কিপ্যায়েট্যাক্স্স যতক্ষণ না ফেয়ারসাম এটির কাছাকাছি চলে আসে, আশা করি এটি সহায়তা করবে: শামুকগুলি একটি 2 ডি প্যাটার্নের সাথে মিলে যায় ভাষা। udlrশামুকের দিকটি উপরে / নীচে / বাম / ডানদিকে সেট করুন। |এটি নিয়মিত রেজেক্সের মতো কাজ করে এবং এর জন্য )কোনও মিলে ওপেন বন্ধনী প্রয়োজন নেই। সুতরাং কোডটি বেশ সহজেই অনুবাদ করে "এর মধ্যে একটি সন্ধান করুন v<>^এবং দিকনির্দেশটি যথাযথভাবে সেট করুন, তারপরে সেই দিকটিতে একটি ও খুঁজে পাওয়ার চেষ্টা করুন।"
FryAmTheEggman

হ্যাঁ, অ্যাগম্যান কী বলেছে। শুধুমাত্র অন্যান্য জিনিস যে ,ভালো হয় *Regex করুন।
ফেয়ারসাম

13

রেটিনা, 56 52 42 38 31 30 বাইট

@ মার্টিনবাটনারকে ধন্যবাদ 1 বাইট সংরক্ষণ করা

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

আয়তক্ষেত্রের অপব্যবহারের বৈশিষ্ট্য। একটি ট্রেলিং নিউলাইন রাখতে ইনপুট প্রয়োজন।

এটি অনলাইনে চেষ্টা করুন

ব্যাখ্যা

এটি তিন ভাগে কাজ করে:

  • মেলা >
  • মেলা <
  • সমন্বয় ^এবং vএই কারণ জন্য যুক্তিবিজ্ঞান ^এবং vসত্যিই একই, শুধু অক্ষর।

যাচাই করা হচ্ছে <

এটি সহজ:

O.*<

এটি একটি এর সাথে মেলে O, allyচ্ছিকভাবে অ-নিউলাইন চরগুলি অনুসরণ করে, তারপরে ক<

যাচাই করা হচ্ছে >

এটি পূর্বের পথের মতো প্রায় অন্যান্য পথ বাদে অনেকটা একই। প্রথমে একটি >মিলেছে, তারপরেO

বৈধকরণ ^এবংv

এটি গল্ফের পক্ষে কঠিন ছিল এবং সর্বদা বৈধ হওয়ার কারণে ইনপুটটি রূপান্তরিত করে। প্রথমত, আমরা এটি মিলি vবা এটি একটি O:

[vO]

যদি এটি একটি হয় ^তবে প্রথম চরিত্রটির মুখোমুখি হওয়া উচিত একটি O। সুতরাং, এটি প্রথম চরিত্রের সাথে মেলে। এরপরে আমরা .নিউলাইন পর্যন্ত এটির অনুসরণের পরিমাণ গণনা করি:

(.*\n)

এর পরে, এটি দুটি অংশে যেতে পারে, আমি প্রথমটি কভার করব:

সুতরাং প্রথমে, আমরা নিম্নলিখিতটি Oব্যবহার করে ব্যবহার করছি:

[^O]*O

এটি Ountil চ্ছিকভাবে সমস্ত না-অক্ষরের সাথে মিলে যায় untilO মুখোমুখি , যদি এটি সফল হয় তবে এটি অবিরত থাকে ... যদি তা না হয় তবে নিম্নলিখিতটি ঘটে ...

এখন, এটি ^ব্যবহারের সন্ধান করার চেষ্টা করে:

[^^]*\^

^রেজেক্সে একটি বিশেষ চরিত্র তাই এটি এড়ানো দরকার। [^^]বাদে সমস্ত চরিত্রের সাথে মেলে^ , এটি উপরের মতো একই কাজ করে, যদি এটি সফল হয় তবে নিম্নলিখিতটি ঘটে ...

সুতরাং এখন, উপরেরগুলির একটি সফলতার সাথে মিলছে, \1যাচাই করে গ্রুপটি আগে থেকেই পরীক্ষা করে দেখেছে যে (.*\n)এই ক্যাপচার গ্রুপটি .সেখানে আগে vবা পরে ছিল এমন পরিমাণের পরিমাণ সংরক্ষণ Oকরেছিল, সুতরাং এখন \1কেবল বিন্দুগুলির পরিমাণ পরীক্ষা করে দেখুন একই।


আপনি এর পরিবর্তে ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারেন \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]);}

এবং ungolfed

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;}

এবং ungolfed সংস্করণ

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;
    }

সম্পাদনা হে 'খুঁজছেন আমি rewrote কোড, এখন এটি একক লুপ অনেক খাটো রয়েছে, এবং আমি এও @Frozn পরামর্শ ব্যবহৃত তাদের ASCII মান সঙ্গে অক্ষরের কিছু প্রতিস্থাপন।

ফলস্বরূপ, আরও 30 বাইট ধুলিকে কামড়ায়।

@ ফ্রোজেনের আরেকটি পরামর্শ, এবং আমরা পাইথন সলিউশনের কাছাকাছি কয়েকটি বাইট

অন্য পুনর্লিখন একটি লুপ ড্রপ, এবং বিবৃতি যদি দুটি একত্রিত


1
+1 আপনি যদিও বাইটের মাঝে returnএবং (সেভ করার জন্য জায়গাটি সরাতে পারেন । আপনার রিটার্ন মান যখন প্রথম বন্ধকের (বা স্ট্রিংসের উদ্ধৃতি) এর অভ্যন্তরে থাকে তখন স্থানটির প্রয়োজন হয় না। জাভা কোড-গল্ফিং টিপস থেকে উত্স।
কেভিন ক্রুইজসেন 20'16

@ কেভিন ক্রুজসেন খুব বেশি সঞ্চয় করছেন না, তবে ধন্যবাদ :)
ব্যবহারকারী 902383

প্রতিটি অল্প অল্প (বা আমি বাইতে বলা উচিত) অনুমান করতে সহায়তা করে। ;) তদুপরি, আমি মনে করি না যে জাভা কোনওভাবেই কোনও কোড-গল্ফ চ্যালেঞ্জ জিততে পারে। আমি এখনও জাভাতে কোড-গল্ফ চ্যালেঞ্জগুলি করতে চাই, বিশেষত যেহেতু আমি বর্তমানে জাভা নিয়ে কাজ করছি।
কেভিন ক্রুইজসেন

আপনি তাদের ASCII মান দ্বারা অক্ষর প্রতিস্থাপন করতে পারেন: 'O' = 79, '>' = 62, '<' = 60, '^' = 94। 'ভি' এর জন্য এটি 118 তবে এটি কোডটি ছোট করে না।
হিমশীতল

কেভিন বলেছেন যেমন @ ফ্রোজেন, প্রতি বাইট গণনা।
ব্যবহারকারী 902383

7

এমএটিএল (কোনও রেজেক্স নেই), 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

@ লুইস মেন্ডো কীভাবে পরিত্রাণ পাবেন তা নির্ধারণ করার জন্যJ
সুইভর

আমি এমএটিএল জানি না, সুতরাং এটি একটি নির্বোধ প্রশ্ন হতে পারে, তবে কেন 0 প্রধান?
নীল

3
@ নীল এটি চিঠি 'O', সংখ্যা নয় 0। চিঠির জন্য ASCII কোড 'O'হল79
লুইস Mendo

ওহ, আমি অনুমান করি যে আপনি যদি এর পরিবর্তে বিজোড় সংখ্যাগুলি সন্ধান করতে চান তবে আমি বোকা হয়ে থাকতাম।
নিল

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% উপরের ।

মূল গ্রিডের জন্য "
ভাল" স্ট্রিংগুলি হ'ল " > ও" এবং "ও <" এবং তারা ফলাফলটি স্থানান্তরিত গ্রিডের জন্য "" ভাল "স্ট্রিংগুলি" ভিও "এবং" ও ^ "এবং তারা ফলাফল 15
" খারাপ "দেয় উভয় গ্রিডের স্ট্রিং হ'ল: ">", "<", "^", "ভি", "ও", "" "ও>", "ওভ", "<ও", "^ ও" এবং তারা দেয় ফলাফল 8, 6, 4, 10, 7, 0, 1, 3, 1, 3


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

টিএসকিউএল (স্কেলসার্ভার 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)

অনলাইন সংস্করণটি কার্যকর করতে বাধ্য করার জন্য ঘোষণায় মজাদার লিনচেঞ্জ ব্যবহার করতে হয়েছিল (ইনপুট ভেরিয়েবলগুলিকে মান নির্ধারণের ফলে দৈর্ঘ্যের গণনাটি কোনওভাবেই প্রভাব ফেলবে না)

এটি অনলাইন চেষ্টা করুন!



2

JavaScript (ES6), 78 bytes

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

Regexp of course. Turned out to be similar in principle to the Ruby answer.


2

Ruby, 71 55 54 bytes

Regex solution, which means that it's probably going to be easily beaten by Retina or Perl.

Returns an index number (truthy) if there is a match.

Now with a similar trick to @Downgoat Retina answer, matching for down and up beams at the same time.

->m{m=~/>\.*O|O\.*<|(?=[vO])(.{#{??+m=~/\n/}})+[O^]/m}

2

JavaScript (ES6) (no regex), 126 bytes

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)

Where \n represents the literal newline character.


2

Clojure (no regex), 293 bytes

(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))))

Doesn't feel great. Straightforward solution, finding the index of corresponding characters and calculating if they're on the same line.

You can try it here https://ideone.com/m4f2ra


2

Python (no regex), 105 bytes

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]

returns True or False

First, strips '.' and '\n' from the ends so that the characters of interest, '0<>v^', are the first and last characters.

'>O<vO^'.find(t[0]+t[-1])//3 - checks if the characters are a potentially valid arrangement. Evaluates to 0 for '>O' or 'O<', to 1 for 'vO' or 'O^', and to -1 for anything else.

'\n'in t - checks if the characters are in different rows,
len(t)%(s.find('\n')+1)!=1 - checks if they are in different columns, and
1 - is the default

The not inverts the result selected from the list, so the return expression is equivalent to:

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

2

Julia (no regex), 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)

Function operating on an array of chars, normalizing by rotation, removing rows and columns containing only dots by range indexing and finally checking for location of 'O' taking into account if the remainder b is a column or row vector using matrix multiplication.

Try it online


1

Python 2 (no regex), 268 bytes

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

Truthy and Falsy values returned by the function are 1 and 0, respectively.

I haven't had a chance to golf yet. Honestly, I'm not too hopeful for this one...

Any suggestions would be greatly appreciated!


1

C# (No Regex), 282 bytes

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);}

Works like the java version but transpiled and reduced

Expanded (Explanation included):

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);
}

0

C (ANSI) (No regex), 237 bytes

#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;}

Expanded:

#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;
}

I think I took a decently different approach here compared to the Java or C# implementations. I got coordinates of the 'O' and arrow ((c,d) and (x,y)) and then compared them to see if the arrow was pointing in the correct direction.

Returns 0 if false and 1 if true


0

Grime v0.1, 31 bytes

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

Not a very interesting solution. Prints 1 for truthy instances, and 0 for falsy ones. Try it online!

Explanation

We simply search the input rectangle for a minimal-size (n×1 or 1×n) pattern that contains the laser and target in the correct order. The n` flag makes the interpreter print the number of matches, of which there will always be at most one. The rest of the line consists of four patterns separated by |-characters, which means a logical OR: a rectangle is matched if it matches one of the patterns. The patterns work as follows:

\>.*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 "^"
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.