दो आयामी प्रोग्रामिंग भाषाओं अक्सर दर्पण आदेशों की तरह है /और \ग्रिड पर अनुदेश सूचक रीडायरेक्ट करने के लिए:

>>>>\
    v
    v
<<<</

इस चुनौती में, आपको एक आने वाली दिशा और एक दर्पण दिया जाता है और आपको आउटगोइंग दिशा निर्धारित करने की आवश्यकता होती है।

नियम

आने वाली दिशा पात्रों में से एक के रूप में दी जाएगी NESWऔर दर्पण /या तो दिया जाएगा \। आप इन्हें किसी भी क्रम में प्राप्त कर सकते हैं। आपको बड़े अक्षरों का उपयोग करना चाहिए।

आप किसी भी सुविधाजनक प्रारूप में इनपुट ले सकते हैं, जिसमें दो-वर्ण स्ट्रिंग, वर्णों के बीच कुछ विभाजक का उपयोग करने वाली स्ट्रिंग, सूची में वर्णों की एक जोड़ी, या यहां तक कि सिंगलटन स्ट्रिंग्स की एक जोड़ी शामिल है। यदि आप विभाजक के साथ एक स्ट्रिंग का उपयोग करते हैं, तो विभाजक किसी भी वर्ण का उपयोग नहीं कर सकता है NWSE\/।

आउटपुट एक चरित्र NESWया एकल-वर्ण स्ट्रिंग से होना चाहिए ।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

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

केवल 8 संभावित इनपुट हैं जिन्हें आपको संभालने की आवश्यकता है, इसलिए उन सभी पर आपके कोड का परीक्षण नहीं करने का कोई बहाना नहीं है:

N /   -->   W
N \   -->   E
E /   -->   S
E \   -->   N
S /   -->   E
S \   -->   W
W /   -->   N
W \   -->   S

code-golf string code-golf natural-language code-golf internet stack-exchange-api code-golf code-golf conversion code-golf string code-golf math arithmetic code-golf string whitespace code-golf graphical-output internet code-golf string code-golf string random permutations code-golf string code-golf string

— मार्टिन एंडर
स्रोत

1

उन भाषाओं में जहां बैकस्लैश इनपुट पर बचना चाहिए, क्या हमें यह मानने की अनुमति है कि इनपुट "\\" कहां उचित होगा?

— JDL

4

@JDL वास्तविक स्ट्रिंग (या वर्ण) में एक एकल होना चाहिए \। यदि आपका जवाब एक फ़ंक्शन सबमिशन है जो एक स्ट्रिंग लेता है, तो बेशक आपको \\इसे सही तरीके से कॉल करने के लिए सोर्स कोड की आवश्यकता होगी , लेकिन यदि आप मानक इनपुट से अपना इनपुट पढ़ रहे हैं, उदाहरण के लिए, तो यह एक होना चाहिए \। दूसरे शब्दों में, यदि आप इनपुट पर अपनी भाषा के संबंधित स्ट्रिंग-लंबाई फ़ंक्शन को कॉल करते हैं, तो परिणाम हमेशा समान होना चाहिए, भले ही इनपुट में कोई भी हो /या \।

— मार्टिन एंडर

ठीक है, मैं R से समस्याओं की उम्मीद कर रहा था जब एक unescaped "\" को स्टड के माध्यम से दर्ज किया गया था, लेकिन readline()इसे संभाल सकता है।

— JDL

1

@JDL आपको संभवतः उस प्रतीक से बचने वाले स्ट्रिंग (डुप्लिकेटिंग) में प्रवेश करना होगा , लेकिन परिणामी स्ट्रिंग "N \" होगी

— लुइस

24

पायथन, 40 38 बाइट्स

-2 बाइट्स के लिए @MitchSchwartz (ord(d)+ord(m))%8-> धन्यवादord(d)+ord(m)&7

lambda d,m:' NESSWNW'[ord(d)+ord(m)&7]

काम करने वाले अध्यादेशों के योग के सबसे छोटे मोड द्वारा अनुक्रमित एक सूची (AKA स्ट्रिंग) में उत्तर की सादा खोज।

टेस्ट केस आइडियन पर हैं

— जोनाथन एलन
स्रोत

डंगिट, मुझे लगा कि मैं ASCII मूल्यों को लेने, %8उन्हें समेटने, और एक सूचकांक करने के लिए सुपर चालाक हो रहा था । फिर मैं देखता हूं कि आपने एक घंटे पहले वही समाधान पोस्ट किया था। हा। एक +1 है।

— AdmBorkBork

21

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

lambda c,m,k="NWES":k[k.find(c)^(m>k)+1]

Sp3000 ने एक बाइट ( .index→ .find) को बचाया ।

व्याख्या

हम दिशाओं को मैप करना चाहते हैं जैसे:

       \
  N ⇄⇄⇄⇄⇄⇄⇄ E
  ⇅         ⇅
  ⇅         ⇅
/ ⇅         ⇅ /
  ⇅         ⇅
  ⇅         ⇅
  W ⇄⇄⇄⇄⇄⇄⇄ S
       \

हम दिशा-निर्देश 2-बिट कोड असाइन कर सकते हैं, और पहले और दूसरे बिट्स के XOR-ing के रूप में दोनों फ़्लिप देख सकते हैं:

         xor 2
     0 0 ⇄⇄⇄⇄⇄ 1 0
      ⇅         ⇅
      ⇅         ⇅
xor 1 ⇅         ⇅ xor 1
      ⇅         ⇅
      ⇅         ⇅
     0 1 ⇄⇄⇄⇄⇄ 1 1
         xor 2

स्ट्रिंग के उपयोग से बिट स्ट्रिंग्स और दिशाओं के बीच मैपिंग होती है k। अब हम सिर्फ दर्पण वर्ण मैप करने की आवश्यकता '/'और '\\'मूल्यों के लिए 1और 2। चूंकि '/' < '\\', हम भोलेपन (m>'/')+1को एक सूत्र के रूप में उपयोग कर सकते हैं । लेकिन रुकें! कोषगत,

'/' < 'NWES' < '\\'

और हम 'NWES'अच्छी तरह से सौंपा गया है k! इसलिए हम (m>k)+1इसके बजाय उपयोग कर सकते हैं ।

— लिन
स्रोत

12

CJam, 14 बाइट्स

(@MartinEnder ने मेरे पायथन जवाब को पोर्ट किया )

l1b" NESSWNW"=

कैसे?

l1b" NESSWNW"= -
l              - read input
 1b            - cast characters as base 1 digits
   " NESSWNW"  - the string " NESSWNW"
             = - modulo index into the string

टेस्ट aditsu पर हैं

— जोनाथन एलन
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 50 41 40 37 बाइट्स

d=>m=>(S="NWES")[S.search(d)^-~(m>S)]

तुलना के उपयोग से 3 और बाइट्स सहेजे, लिन के जवाब के लिए धन्यवाद

प्रयोग

let f =
d=>m=>(S="NWES")[S.search(d)^-~(m>S)]

console.log(f("N")("/"));  //   -->   W
console.log(f("N")("\\")); //   -->   E
console.log(f("E")("/"));  //   -->   S
console.log(f("E")("\\")); //   -->   N
console.log(f("S")("/"));  //   -->   E
console.log(f("S")("\\")); //   -->   W
console.log(f("W")("/"));  //   -->   N
console.log(f("W")("\\")); //   -->   S

स्निपेट का विस्तार करें

— Arnauld
स्रोत

एएससीआईआई की तुलना का चालाक उपयोग आपके रास्ते को समाप्त करने के लिए आपकी स्थिति को खेलने के लिए ...

— वेलेवेस्ट

6

MATL , 19 17 बाइट्स

'NWSE'jy&mjy+Eq-)

इसे ऑनलाइन आज़माएं! या आठ मामलों को सत्यापित करें ।

व्याख्या

'NWSE'    % Push this string
j         % Take first input, say 'W'. Stack contains: 'NWSE', 'W'
y         % Duplicate from below. Stack: 'NWSE', 'W', 'NWSE'
&m        % Index of membership. Stack: 'NWSE', 2
j         % Take second input, say '/'. Stack: 'NWSE', 2, '/'
y         % Duplicate from below. Stack: 'NWSE', 2, '/', 2
+         % Add (char '/' is converted to code point). Stack: 'NWSE', 2, 49 
Eq        % Multiply by 2, subtract 1. Stack: 'NWSE', 2, 97
-         % Subtract. Stack: 'NWSE', -95
)         % Apply -95 as (modular, 1-based) index into 'NWSE'. Stack: 'N'
          % Implicitly display

— लुइस मेंडो
स्रोत

6

पायथ, 17 16 15 बाइट्स

# बाइट के लिए @ जेक्यूब और @ मेल्टेंसन को धन्यवाद

@J"NWES"xxJQh>E

एक प्रोग्राम जो दो न्यूलाइन-अलग-अलग उद्धृत स्ट्रिंग्स का इनपुट लेता है, पहले दिशा और फिर दर्पण, और परिणाम प्रिंट करता है।

यह @ लिन के पाइथन उत्तर का एक बंदरगाह है ।

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

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

@J"NWES"xxJQh>E  Program. Inputs: Q, E
 J"NWES"         J="NWES". Yield J
         xJQ     J.index(Q)
             >E  E>Q, lexographically (implicit input fill)
            h    +1
        x        Bitwise XOR of the above two
@                Index into J with the above
                 Implicitly print

— TheBikingViking
स्रोत

आप के <QEसाथ बदलकर एक और बाइट बचा सकते हैं >E।

— माल्टसेन 14

4

05AB1E , 14 बाइट्स

‘€Ã‘DIkI'/kÌ^è

‘€Ã‘             # from string "NEWS"
             è   # get element at index
    DIk          # index of 1st input in string "NEWS"
            ^    # XOR
       I'/k      # index of 2nd input in string "/"
           Ì     # +2

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

— Emigna
स्रोत

4

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

(मेरे पायथन जवाब का एक पोर्ट )
-1 बाइट थैंक्स टू @ मर्टिनएंडर (स्ट्रिंग की समाप्ति के लिए एक स्थान जोड़ें और मोडुलो 8 की आवश्यकता को हटा दें)
-1 बाइट के लिए धन्यवाद @LuisMendo (दो से एक एकल स्ट्रिंग तर्क लें)

OSị“NESSWNW

कैसे?

OSị“NESSWNW  - takes a single argument "dm" (direction and mirror), in either order.
                   strings and lists are equivalent in Jelly
 O            - ordinal: [ord(d),ord(m)]
  S           - sum: ord(d)+ord(m)
    “NESSWNW  - string: "NESSWNW "
   ị          - fetch modulo index (the string is 8 long and 1-based)

यह TryItOnline पर परीक्षण करें

— जोनाथन एलन
स्रोत

4

जावा 7, 71 70 68 बाइट्स

char c(int d,int m){return"NEWS".charAt("NEWS".indexOf(d)^-~(m%2));}

बहुत बुरा है charAtऔर indexOfइतना बाइट लेता है ..

Ungolfed और सभी परीक्षण मामले:

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

class M{
  static char c(int d, int m) {
    return "NEWS".charAt("NEWS".indexOf(d) ^ -~(m%2));
  }

  public static void main(String[] a){
    System.out.print(c('N', '/') + " ");
    System.out.print(c('N', '\\') + " ");
    System.out.print(c('E', '/') + " ");
    System.out.print(c('E', '\\') + " ");
    System.out.print(c('S', '/') + " ");
    System.out.print(c('S', '\\') + " ");
    System.out.print(c('W', '/') + " ");
    System.out.print(c('W', '\\') + " ");
  }
}

आउटपुट:

W E S N E W N S

— केविन क्रूज़सेन
स्रोत

3

पायथन, 63 61 59 बाइट्स

lambda d,m,x='NESW'*2:x[x.find(d)+2*(m=='/\\'[d in'NS'])-1]

बहुत साधारण। निश्चित रूप से अधिक गोल्फ हो सकता है। तय करता है कि इनपुट के इंडेक्स में 1 या -1 को जोड़ना है या नहीं 'NESW'।

यह एक लंबोदर अभिव्यक्ति है; इसका उपयोग करने के लिए, इसके साथ उपसर्ग करें f=।

Ideone यह!

— तांबा
स्रोत

3

जावा 8, 62 58 56 बाइट्स

(d,m)->"SEWN".charAt("NWES".indexOf(d)^m.indexOf(47)+2);

अनगढ़ परीक्षण कार्यक्रम

import java.util.function.BiFunction;

public class Mirror {

public static void main(String[] args) {
    BiFunction<String, String, Character> function = (d,m)->"SEWN".charAt("NWES".indexOf(d)^m.indexOf(47)+2);

    System.out.println(function.apply("N", "/")); //W
    System.out.println(function.apply("N", "\\")); //E
    System.out.println(function.apply("W", "/")); //N
    System.out.println(function.apply("W", "\\")); //S
    System.out.println(function.apply("E", "/")); //S
    System.out.println(function.apply("E", "\\")); //N
    System.out.println(function.apply("S", "/")); //E
    System.out.println(function.apply("S", "\\")); //W
}

}

— शॉन वाइल्ड
स्रोत

3

PowerShell v2 +, 34 बाइट्स

param($a,$b)"xNESSWNW"[(+$a+$b)%8]

इनपुट को दो स्पष्ट chars के रूप में लेता है , आउटपुट a char।

यह काम करता है इस प्रकार है: अगर हम प्रकार उत्पादन, हम चाहते हैं S /किसी भी तरह के रूप में ही बराबर करने के लिए N \, W /बराबर करने के लिए E \, आदि या, कम से कम, उपज संख्या कि "बंद पर्याप्त" अभी भी कर रहे हैं अभी तक अलग। यदि हम ASCII मूल्यों को देखते हैं, तो हमें नीचे की तरह एक तालिका मिलती है:

In1   In2       Res.    Sum
S 83  / 47  --> E 69 -> 130
N 78  \ 92  --> E 69 -> 170
W 87  / 47  --> N 78 -> 134
E 69  \ 92  --> N 78 -> 161
W 87  \ 92  --> S 83 -> 179
E 69  / 47  --> S 83 -> 116
N 78  / 47  --> W 87 -> 125
S 83  \ 92  --> W 87 -> 175

सारांश कॉलम (इनपुट्स के ASCII कोड बिंदुओं के योग से प्राप्त) पर एक त्वरित ब्रूट-फोरसर चलाने से पता चलता है कि यदि हम रकम मॉडुलो लेते हैं 8, तो हमें निम्नलिखित मिलते हैं 2 2 | 6 1 | 3 4 | 5 7। यही कारण है कि स्ट्रिंग से जाहिर होता है है "xNESSWNW", के रूप में Eसूचकांक में है 2, Nपर है 6और 1, और इतने पर।

तो, हम सिर्फ आदानों (परोक्ष से कास्टिंग योग करने के लिए की जरूरत charके लिए int32रास्ते में), कि ले %8, और उपयोग है कि हमारे स्ट्रिंग में सूचकांक के लिए।

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

PS C:\Tools\Scripts\golfing> ('N','/'),('N','\'),('E','/'),('E','\'),('S','/'),('S','\'),('W','/'),('W','\')|%{"$($_[0]) $($_[1]) --> "+(.\mirror-mirror-in-the-code.ps1 ([char]$_[0]) ([char]$_[1]))}
N / --> W
N \ --> E
E / --> S
E \ --> N
S / --> E
S \ --> W
W / --> N
W \ --> S

— AdmBorkBork
स्रोत

2

बैच, 111 बाइट्स

:goto %1
:W/
:E\
@echo N
@exit/b
:S/
:N\
@echo E
@exit/b
:E/
:W\
@echo S
@exit/b
:N/
:S\
@echo W

W/दो-वर्ण स्ट्रिंग कमांड लाइन पैरामीटर के रूप में उदाहरण स्वीकार करता है। \और /अजीब पाशन बनाते हैं; इसने 124 बाइट ली होंगी।

— नील
स्रोत

Idk, मैं 96 बाइट्स गिनता हूं। क्या आपने इससे पट्टी की \r?

— कॉनर ओ'ब्रायन

@ ConorO'Brien मैं नोटपैड का उपयोग करके अपनी बैच फ़ाइलों को लिखता हूं, इसलिए, नहीं।

— नील

2

ऑक्टेव, 30 बाइट्स

जोनाथन एलन के रूप में तर्कों के उसी क्रम का उपयोग किया।

इनपुट को दो-वर्ण स्ट्रिंग के रूप में लेता है 'W\'।

@(x)['NESSWNW'](mod(sum(x),8))

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

— स्टीवी ग्रिफिन
स्रोत

अच्छा! आप MATL पर पोर्ट करना चाहते हैं: 'NESSWNW 'is)( सभी परीक्षण मामलों को देखें )। iहै input, sहै sum, और )अनुक्रमण है, जो मॉड्यूलर है। मैंने स्ट्रिंग में एक स्थान जोड़ा ताकि मॉडुलो 8 है

— लुइस मेंडो सेप

धन्यवाद :) मुझे लगता है कि यह धोखा है अगर मैं इसे एक अलग उत्तर के रूप में जोड़ता हूं, क्योंकि मैंने इसे खुद नहीं लिखा है। मैं इसे इस उत्तर में जोड़ सकता हूं, हालांकि यदि आप स्वयं इसका उत्तर नहीं देना चाहते हैं :)

— स्टीवी ग्रिफिन

मैं समझता हूं, मैं शायद ऐसा ही करूंगा :-) मैं अपना जवाब संशोधित नहीं करना चाहता, क्योंकि यह पूरी तरह से एक अलग दृष्टिकोण है जिसके साथ मैं नहीं आया था। यह सुनिश्चित नहीं है कि इसे आपके उत्तर में जोड़ना समझ में आता है, हालांकि, उत्तर में यह दो अलग-अलग भाषाएं होंगी

— लुइस मेंडू सेप

हालांकि यह मेरा पहला MATL उत्तर होगा: PI देखें यह आपके MATL उत्तर से अधिक लंबा है, इसलिए मुझे नहीं लगता कि मैं इसे जोड़ूंगा ...

— Stewie Griffin

2

सी, 44, 35, 34 बाइट्स

f(a,b){return"NWES"[a&a/2&3^b&3];}

इसमें दो वर्णों के रूप में दो वर्णों की आवश्यकता होती है। यह निचले और ऊपरी दोनों मामलों में होता है। इसमें बहुत अधिक हेरफेर का उपयोग होता है। टुकड़े a&a/2में एक परिणाम होता है जिसमें निचले दो बिट्स के लिए अद्वितीय मान होते हैं, &3सभी उच्च बिट्स को काटते हैं। यह \दर्पण के लिए स्ट्रिंग "एनडब्ल्यूईएस" में एक सूचकांक के रूप में उपयोग किया जाता है । सौभाग्य से, ASCII वर्ण के निचले दो बिट्स \और /00 और 11 क्रमशः है, जो ऊपर उल्लिखित सूचकांक के लिए सही दिशा पाने के लिए के साथ XOR के लिए एकदम सही है /दर्पण।

— जी। स्लीपेन
स्रोत

2

अच्छा! आप एक स्पष्ट -1 बाइट से चूक गए, हालांकि: return"NWES"[...](स्थान छोड़ दें)।

— टिम Timस

धन्यवाद टिम, यह मुझे नहीं पता था कि यह वैध होगा :) :)

— जी। स्लिपपेन

1

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

r"SWEN"_e!r'/#=er

इनपुट अंतरिक्ष-पृथक है।

इसे ऑनलाइन आज़माएं! (एक लाइनफीड-सेपरेटेड टेस्ट सूट के रूप में।)

यह वह उपाय है जिसे मैंने चुनौती पोस्ट करने से पहले पाया था। जोनाथन के चक्रीय अनुक्रमण के रूप में छोटा नहीं है, लेकिन मुझे लगा कि यह दृष्टिकोण काफी दिलचस्प है (और उपन्यास)।

व्याख्या

लक्ष्य का उपयोग ट्रांसलिटरेशन (यानी कैरेक्टर-टू-कैरेक्टर मैपिंग का उपयोग करके) को आउटपुट कैरेक्टर के साथ इनपुट कैरेक्टर को बदलने के लिए किया जाता है। ऐसा करने के लिए, हम चाहे दर्पण है के आधार पर सही मानचित्र का चयन करना /या \। हम SWENसूची से दूसरे में मैप करेंगे जिसे हम सशर्त रूप से चुनेंगे। यदि इनपुट सूची है SWEN, तो दो आउटपुट मैप निम्न होने चाहिए:

in  SWEN
/   ENSW
\   WSNE

ध्यान दें कि ये क्रमबद्ध और रिवर्स-सॉर्ट किए गए क्रम में हैं (यही कारण है कि हमने SWENइनपुट सेट के रूप में प्रतीत होता है यादृच्छिक क्रम चुना )। हम इनपुट सूची को छाँटकर और यदि इनपुट है तो परिणाम को उल्टा करके उत्पन्न कर सकते हैं \, लेकिन इसका एक बेहतर तरीका है:

r       e# Read incoming direction.
"SWEN"  e# Push input list for transliteration.
_e!     e# Duplicate and get all permutations. The way, `e!` is implemented, it
        e# always gives the permutations in sort order, regardless of the order
        e# of the input set. Specifically that means that "ENSW" will be first
        e# and "WSNE" will be last in this list.
r       e# Read the mirror.
'/#     e# Find the index of / in this string. If the mirror is '/', then this
        e# gives 0. Otherwise, this gives -1, indicating that '/' was not found.
=       e# Select the corresponding permutation. Indexing is zero-based and
        e# cyclic so that 0 (input '/') gives the first permutation "ENSW" and
        e# -1 (input '\') gives the last permutation "WSNE".
er      e# Perform the transliteration on the incoming direction.
        e# Printing is implicit.

— मार्टिन एंडर
स्रोत

1

SED 48 (42 + 1 for -r) 43

मार्टिन एंडर को 5 धन्यवाद दिए गए Martin

s,N/|S\\,W,;s,E/|W\\,S,;s,N.|S/,E,;s,..,N,

इनपुट को दो वर्ण स्ट्रिंग के रूप में लेता है।

— रिले
स्रोत

0

गणितज्ञ, 98 बाइट्स

If[#2=="/",{"S",,,,,,,,,"W",,,,,"E",,,,"N"},{"N",,,,,,,,,"E",,,,,"W",,,,"S"}][[LetterNumber@#-4]]&

अनाम फ़ंक्शन। इनपुट के रूप में दो तार लेता है और आउटपुट के रूप में एक स्ट्रिंग लौटाता है।

— LegionMammal978
स्रोत

0

सी, 81 बाइट्स

f(char*a){return a!="N/"&a!="S\\"?a!="N\\"&a!="S/"?a!="W\\"&a!="E/"?78:83:69:87;}

प्रयोग

main()
{
    printf("N/ \t %c\n",f("N/"));
    printf("N\\\t %c\n",f("N\\"));
    printf("E/ \t %c\n",f("E/"));
    printf("E\\\t %c\n",f("E\\"));
    printf("S/ \t %c\n",f("S/"));
    printf("S\\\t %c\n",f("S\\"));
    printf("W/ \t %c\n",f("W/"));
    printf("W\\\t %c\n",f("W\\"));
}

आउटपुट:

N/      : W  
N\      : E  
E/      : S  
E\      : N  
S/      : E  
S\      : W  
W/      : N  
W\      : S

— जियाकोमो गारबेलो
स्रोत

पॉइंटर तुलनाओं का उपयोग करने के बाद से केवल हार्डकोड के मूल्यों पर काम करता है।

— सामी कुहोमेन

0

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

@."EW¹0`Y"sCM

परीक्षण सूट

कोड अंक, मॉड्यूलर इंडेक्स, कंप्रेस्ड स्ट्रिंग को योग करें।

— isaacg
स्रोत

0

टीआई-बेसिक, 40 बाइट्स

इनपुट्स को हार्डकोड करता है। बोरिंग, लेकिन सबसे छोटा रास्ता।

sub("NEWS",1+int(inString("E/W\N\S/N/S\E\W/",Ans)/4),1

— Timtech
स्रोत

दर्पण, दर्पण, संहिता में

नियम

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

पायथन, 40 38 बाइट्स

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

व्याख्या

CJam, 14 बाइट्स

जावास्क्रिप्ट (ईएस 6), 50 41 40 37 बाइट्स

प्रयोग

MATL , 19 17 बाइट्स

व्याख्या

पायथ, 17 16 15 बाइट्स

05AB1E , 14 बाइट्स

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

जावा 7, 71 70 68 बाइट्स

पायथन, 63 61 59 बाइट्स

जावा 8, 62 58 56 बाइट्स

अनगढ़ परीक्षण कार्यक्रम

PowerShell v2 +, 34 बाइट्स

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

बैच, 111 बाइट्स

ऑक्टेव, 30 बाइट्स

सी, 44, 35, 34 बाइट्स

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

व्याख्या

SED 48 (42 + 1 for -r) 43

गणितज्ञ, 98 बाइट्स

सी, 81 बाइट्स

प्रयोग

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

टीआई-बेसिक, 40 बाइट्स