कार्डिनल कोड चैलेंज

Question

कार्य

आप कम्पास बनाने के प्रभारी हैं, प्रकार के।

कम्पास "सुई" के रूप में अपने स्रोत कोड की कल्पना करें जहां विभिन्न झुकावों पर चलने से अलग आउटपुट का उत्पादन होता है।

समर्थित स्रोत कोड ओरिएंटेशन उत्तर, पूर्व, दक्षिण और पश्चिम हैं।

उदाहरण

मान लें कि आपके पास स्रोत कोड है:

ABCD
 J K
WXYZ

हम इसे नॉर्थ ओरिएंटेशन मानेंगे, 90 डिग्री को दक्षिणावर्त घुमाते हुए हमें पूर्व की ओर इशारा करेंगे:

W A
XJB
Y C
ZKD

घूर्णन फिर से अंक दक्षिण:

ZYXW
K J 
DCBA

और अंत में, पश्चिम के लिए अंतिम रोटेशन:

DKZ
C Y
BJX
A W

जब भाग गया, तो उपरोक्त कोड उदाहरणों में से प्रत्येक को आपके चयन के एकल, विशिष्ट मुद्रण योग्य ASCII चरित्र का उत्पादन करना चाहिए ।

टिप्पणियाँ

आपका कोड कोई इनपुट नहीं लेगा

खाली स्थान या नई लाइनें घूमते समय गिर / गायब नहीं होती हैं।

आउटपुट में नई लाइनों को लीड करना / पीछे करना ठीक है।

उत्तर पूरे कार्यक्रम या फ़ंक्शन हो सकते हैं, इस प्रकार STDOUT में आउटपुट या फ़ंक्शन परिणाम वापस कर सकते हैं।

मानक कोड-गोल्फ नियम लागू होते हैं; बाइट्स जीत में सबसे कम जवाब!

Comments

क्या हम 1 से अधिक वर्ण का उत्पादन कर सकते हैं?

— श्री एक्सकोडर

क्या हमें रिक्त स्थान के साथ कोड को पैड करना है ताकि यह एक सही आयत हो (और हमारे स्कोर में उन स्थानों को गिनें)? उदाहरण के लिए, क्या इस तरह का कोड मान्य होगा, जो पहले प्रस्तुत किया गया हो?

— बिजनेस कैट

आउटपुट स्पेक के अलावा, मुझे लगता है कि यह

— डिजिटल ट्रामा

@BusinessCat आपको आयत बनाने के लिए अपने कोड को पैड करने की आवश्यकता नहीं है - जो उदाहरण आपने दिया है वह मान्य होगा।

— CzarMatt

@ Mr.Xcoder उम, कैसे 4 समान कार्यक्रम 4 विभिन्न ASCII वर्ण प्रिंट कर सकते हैं?

— ETHproductions

Answer 1

जेली , 2 बाइट्स

*2

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

ध्यान दें कि एक जेली कार्यक्रम के लिए मुख्य प्रविष्टि इसकी अंतिम कड़ी है, जहां कोई भी नया चरित्र लिंक को विभाजित करेगा), न तो दो-पंक्ति कार्यक्रमों में वास्तव में उनके शीर्ष लिंक का उपयोग होता है।

चार पूर्ण कार्यक्रम, जिनमें से सभी उनके परिणाम को प्रिंट करते हैं, वे हैं:

उत्तर :

*2   -> (implicit) zero raised to the power of 2 = 0

पूर्व :

*
2    -> literal 2 = 2

दक्षिण :

2*   -> two raised to the power of (implicit) 2 = 4

पश्चिम :

2
*    -> (implicit) zero raised to the power of (implicit) zero = 1

Comments

यह अंतिम उत्तर है। बहुत बढ़िया।

— आउटगॉल्फ

Answer 2

जाप , 3 2 बाइट्स

gy

किसी तरह, किसी तरह , मैं एक बहुत hacky 2-बाइट समाधान पाया ...

---

उत्तर आउटपुट 0:

gy

चूंकि इसमें कोई निहित इनपुट नहीं है, इसलिए यह चूक करता है 0। gएक नंबर पर अपने तर्कों ( "y"इस मामले में) की परवाह किए बिना संख्या का संकेत देता है ।

---

पूर्व आउटपुट 2:

g
y

एक बहु-पंक्ति कार्यक्रम में, पहली पंक्ति इनपुट को उसके परिणाम पर सेट करती है। यह मूल रूप से के बाद से नो-सेशन है, gपर 0है 0। फिर yGCD की वापसी करता है 0और ... जब से यह एक तर्क याद आ रहा है, यह चूक 2(धन्यवाद, @ ओलिवर !)। यह 2आउटपुट के रूप में देता है ।

---

दक्षिण आउटपुट g:

yg

y, पहले की तरह, जीसीडी है। चूंकि gcd (0, x) है एक्स , किसी भी मूल्य के लिए yपर 0सिर्फ अपनी तर्क लौटने की स्वतंत्रता ले जाता है। इस मामले में, तर्क है "g", जो परिणाम है।

---

पश्चिम आउटपुट 1:

y
g

y0 पर, पहले की तरह, रिटर्न 2। यह तब पारित किया जाता है g, जो (पहले से ही चर्चा की गई) संख्याओं पर हस्ताक्षर कार्य है। इसलिए, परिणाम है 1।

Answer 3

जावा (ओपनजेडके 8) , 7309 4421 855 बाइट्स

^{-2888 बाइट्स लीज नून
-3566 बाइट्स के लिए धन्यवाद गेहूं के जादूगर को धन्यवाद}

//i/////////////////////////////////////////////////////////////
//n//////////////////////////////////////////////////////////////////
interface M{static void main(String[]a){System.out.println(0);}}/////
//e//}};)2(nltnirp.tuo.metsyS{)a][gnirtS(niam diov citats{M ecafretni
//r//////////////////////////////////////////////////////////////////
//f}/////////////////////////////////////////////////////////////////
//a}//
//c;//
//e)//
// 3//
//M(//
//{n//
//sl//
//tt//
//an//
//ti//
//ir//
//cp//
// .//
//vt//
//ou//
//io//
//d.//
// m//
//me//
//at//
//is//
//ny//
//(S//
//S{//
//t)//
//ra//
//i]//
//n[//
//gg//
//[n//
//]i//
//ar//
//)t//
//{S//
//S(//
//yn//
//si//
//ta//
//em//
//m //
//.d//
//oi//
//uo//
//tv//
//. //
//pc//
//ri//
//it//
//na//
//tt//
//ls//
//n{//
//(M//
//1 //
//)e//
//;c//
//}a//
//}f//
///r//
///e//
 //t//
 //n//
 //i//

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

पुराना संस्करण

कोड ^ 2 वर्ग को लपेटने वाली टिप्पणियों के साथ सीधा aproach, यह किसी भी भाषा में किया जा सकता है।
अजगर में एक (अधिक पठनीय) उदाहरण

##p#####
# r  2 #
print 1#
# n  t #
# t  n #
#4 tnirp
# 3  r #
#####p##

Comments

महान सामान्य मूल्यांकन, अब मुझे सिर्फ यह पता लगाना है कि यह कैसे करना है! :)

— निर्दोष

आप interface M{static void main(String[]a){System.out.println(0);}}इसके बजाय कुछ बाइट्स को बचाने के लिए उपयोग कर सकते हैं ।

— लीक नुन्

यह काम होगा? इसका रास्ता छोटा है

— गेहूं जादूगर

@MagicOctopusUrn यह हाथ c द्वारा नहीं किया गया था;

— रॉड

@MagicOctopusUrn nah, मैंने इस एल्गोरिथम को दिखाने के लिए इसका उत्तर दिया, भाषा अप्रासंगिक है: 3

— रॉड

Answer 4

ब्रेन-फ्लैक , 33 बाइट्स

##)(##))()()  ((
((  ))##    ()##

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

ब्रेन-फ्लैक , 33 बाइट्स

##)     ## #
(( ))#)())()
  # ( (

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

ब्रेन-फ्लैक , 36 बाइट्स

#)##     ## #
  (())#)())()
 #   ( (

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

ब्रेन-फ्लैक , 38 बाइट्स

######  (#
(()()())#))((
       #(  ##

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

ब्रेन-फ्लैक , 41 बाइट्स

##(#####(#
(()()())#
##))()((
####((#)#)#

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

Comments

बकवास! मैं एक पर काम कर रहा था, लेकिन मुझे कहीं भी नहीं मिला। मैंने सोचा था कि कुछ काम करने में 30-40 मिनट लगेंगे। ये अद्भुत है!

— DJMcMayhem

यह बहुत अच्छा है!

— CzarMatt

आपको गोल्फ करने की कोशिश: पी अब तक उनमें से 3 काम कर रहे हैं

— क्रिस्टोफर

Answer 5

ऐलिस , 17 बाइट्स

1/ 3<
vPo</
5} @<

आउटपुट 1। इसे ऑनलाइन आज़माएं!

5v1
}P/
 o 
@<3
</<

आउटपुट x। इसे ऑनलाइन आज़माएं!

<@ }5
/<oPv
<3 /1

आउटपुट 5। इसे ऑनलाइन आज़माएं!

</<
3<@
 o 
/P}
1v5

आउटपुट 3। इसे ऑनलाइन आज़माएं!

Answer 6

Befunge, 17 13 बाइट्स

मैंने सोचा कि बेफ़ुंज एक ज्यामितीय समस्या के लिए मजेदार होगा। यहां दूसरों के लिए एक तुच्छ 4x4 समाधान है (मुझे 3 कमांड की आवश्यकता है) लेकिन मैं थोड़ा बेहतर तरीके से प्रबंधित हुआ।

संपादित करें: newlines के बारे में भूल गया

संपादित 2: एहसास हुआ कि मैं एक बिल्ली बना सकता हूं

संपादन 3: बिल्ली मर चुकी है

2v3
@.v
.  
1@.

आरआईपी किटी: <

1.@ 2
^._.^
3 @.4

Answer 7

05AB1E , 5 3 बाइट्स

Y'X

उत्तर , पूर्व , दक्षिण , पश्चिम

Comments

प्रभावशाली, कि जल्दी था!

— CzarMatt

@MagicOctopusUrn मुझे लगता है कि Y'Xकाम करेगा, लेकिन मुझे अभी भी कोशिश करनी है।

— रिले

@ यह करता है, यह भी आगे और पीछे काम करता है, Y'Xभी मान्य है। हालांकि एक 2-बाइट की तलाश है; कोई भी 'डॉट कमांड' इसके लिए काम नहीं करता है, इसलिए मुझे संदेह है कि यह मौजूद है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn मुझे नहीं लगता कि जिस तरह से नईलाइन्स काम कर रही हैं उसके साथ 2 बाइट समाधान है। हालांकि फोर्स को बुलाना मुश्किल नहीं होगा।

— रिले

10काम होता अगर वे एक आउटपुट के लिए कई पात्रों की अनुमति देते; पी। *

— मैजिक ऑक्टोपस Urn

Answer 8

सी (जीसीसी) , 283 279 209 बाइट्स

/////////)pm//
/////////;ua//
main(){//}ti//
puts("N"//sn//
);}///////((//
//////////")//
///"//////W{//
///E//////"///
//)"//////////
//((///////};)
//ns//"S"(stup
//it}//{)(niam
//au;/////////
//mp)/////////

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

एक ही पुरानी टिप्पणी चाल यहाँ, लेकिन कम से कम, सी में यह huuuge नहीं मिलता है ;)

• -4, ETHproductions के लिए धन्यवाद !
• निश्चित Wदिशा और -70 (!) ETHproductions द्वारा टिप्पणियों के लिए धन्यवाद बाइट्स

Comments

क्या आपको अंतराल के ठीक ऊपर दाहिने किनारे पर चार स्लैशों में से किसी की आवश्यकता है?

— ETHproductions

हे .. उम्म ... मुझे लगता है, वास्तव में ... नहीं। अच्छी पकड़, धन्यवाद :)

— फेलिक्स पाम्स

मुझे लगता है कि आप इसे );}नीचे की पंक्ति में ले जाकर प्रत्येक को बहुत अधिक कसकर एक साथ पैक कर सकते हैं, जैसे कि (मैंने घुमावों का परीक्षण नहीं किया है)

— ETHproductions

ओह, Wआपके वर्तमान सेटअप में प्रोग्राम वर्तमान में विफल रहता है क्योंकि snवास्तविक कोड के बाद एक अतिरिक्त है । जाहिरा तौर पर आप pmशीर्ष लाइन पर अर्धविराम से पहले स्लैश को बदलकर इसे ठीक कर सकते हैं ।

— ETHproductions

उह ... शायद इसे हटाने और शुरू करने का समय: ओ (पहला संस्करण स्लैश का एक वर्ग था, लेकिन मुझे लगा कि मैं एक " चतुर " बात करूँगा कुछ बाइट्स बचा रहा है ...

— डैमिट

Answer 9

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

!
2@2
 !)

प्रिंट करता है 0। इसे ऑनलाइन आज़माएं!

 2)
 @!
!2

प्रिंट करता है 3। इसे ऑनलाइन आज़माएं!

)!
2@2
  !

प्रिंट करता है 1। इसे ऑनलाइन आज़माएं!

 2!
!@
)2

प्रिंट करता है 2। इसे ऑनलाइन आज़माएं!

व्याख्या

प्रत्येक कार्यक्रम पढ़ने के क्रम में पहले गैर-स्थान पर शुरू होता है (यानी या तो शीर्ष बाएं या शीर्ष केंद्र चरित्र), पूर्व की ओर बढ़ रहा है। पहले कार्यक्रम के लिए:

!   Print an implicit zero.
    The IP can't move east, so it moves south instead.
2   Push a 2.
    The IP can't keep going south, so it turns east instead.
@   Terminate the program.

दूसरे कार्यक्रम के लिए:

2   Push a 2.
)   Increment it to 3.
    The IP can't keep going east, so it turns south instead.
!   Print the 3.
    The IP can't keep going south, so it turns west instead.
@   Terminate the program.

तीसरे कार्यक्रम के लिए:

)   Increment an implicit zero to 1.
!   Print the 1.
    The IP can't keep going east, so it turns south instead.
@   Terminate the program.

चौथे कार्यक्रम के लिए:

2   Push a 2.
!   Print the 2.
    The IP can't keep going east, so it turns back around to move west.
2   Push another 2.
    The IP can't keep going west, so it turns south instead.
@   Terminate the program.

Answer 10

वम्पस , 7 बाइट्स

O@$
)))

प्रिंट करता है 0। इसे ऑनलाइन आज़माएं!

)O
)@
)$

प्रिंट करता है 1। इसे ऑनलाइन आज़माएं!

)))
$@O

प्रिंट करता है 3। इसे ऑनलाइन आज़माएं!

$)
@)
O)

प्रिंट करता है 2। इसे ऑनलाइन आज़माएं!

व्याख्या

पहला कार्यक्रम काफी आसान है: Oएक अंतर्निहित शून्य प्रिंट करता है और @कार्यक्रम को समाप्त करता है।

दूसरे कार्यक्रम से शुरू, हमें नियंत्रण प्रवाह को समझने के लिए त्रिकोणीय ग्रिड लेआउट को देखने की जरूरत है:

)   Increment an implicit zero to 1.
O   Print the 1.
))  Two irrelevant increments.
@   Terminate the program.

तीसरे कार्यक्रम के लिए:

))) Increment an implicit zero to 3.
O   Print the 3.
@   Terminate the program.

चौथा वह स्थान है जहाँ यह वास्तव में कायरतापूर्ण हो जाता है। धराशायी लाइनें उन कोशिकाओं को दर्शाती हैं जिन्हें निष्पादित नहीं किया जाता है क्योंकि वे द्वारा छोड़ दिए जाते हैं $:

$   Skip the ).
$   Skip the @.
))  Increment an implicit zero to 2.
O   Print the 2.
))  Two irrelevant increments.
@   Terminate the program.

Comments

सुपर शांत, महान आरेख, भी।

— CzarMatt

Answer 11

पॉवरशेल , 20 11 बाइट्स

#4#
1#3
#2#

अपमानजनक टिप्पणियां ( #) पागलों की तरह, और तथ्य यह है कि पाइप लाइन पर रखा गया एक नंबर आउटपुट है जैसा कि है। उपरोक्त प्रिंट 1। इसे ऑनलाइन आज़माएं!

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

गेहूं जादूगर को धन्यवाद 9 बाइट्स बचा लिया !

Comments

शक्तियों को नहीं जानते, लेकिन यह काम नहीं करेगा ?

— गेहूं जादूगर

@WheatWizard हाँ, वास्तव में। धन्यवाद!

— AdmBorkBork

Answer 12

तारों से , 34 बाइट्स

  zz  
  +   
   .  
    + 
      

या स्थानों के साथ हाइफ़न के रूप में दिखाया गया है ताकि आप उन्हें देख सकें:

--zz--
--+---
---.--
----+-
------

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

Starry में कमांड हैं +, .और कुछ अन्य चीजें हैं, और वे क्या करते हैं, यह निर्धारित किया जाता है कि उनके पहले कितने रिक्त स्थान हैं: n रिक्त स्थान के +साथ n to5 को स्टैक में धकेलता है , और सम संख्या में रिक्त स्थान के साथ प्रिंट करता है। और नई-पंक्तियों को पूरी तरह से नजरअंदाज कर दिया जाता है।.z

पहले 6 रिक्त स्थान हैं, +इसलिए यह 6 15 = 1 धक्का देता है, और .इसे प्रिंट करता है।

और घुमाव:

-----
-----
---+z
--.-z
-+---
-----

इसे ऑनलाइन आज़माएं! यह "8" प्रिंट करता है।

------
-+----
--.---
---+--
--zz--

इसे ऑनलाइन आज़माएं! यह "2" प्रिंट करता है।

-----
---+-
z-.--
z+---
-----
-----

इसे ऑनलाइन आज़माएं! और यह "3" प्रिंट करता है।

Comments

कितनी साफ-सुथरी भाषा है। इसके अलावा, मैंने कभी नहीं कहा कि आपको आयत बनाने के लिए व्हॉट्सएप के साथ पैड लगाना होगा। लेकिन अगर आपका स्रोत रिक्त स्थान पर निर्भर करता है तो मुझे लगता है कि आपको उन्हें गिनना होगा।

— CzarMatt

@CzarMatt, स्पष्टीकरण के लिए धन्यवाद! मैंने पोस्ट अपडेट कर दी है।

— एक पेड़ नहीं

Answer 13

डीसी , 9 बाइट्स

 1
2p3
 4

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

मुझे लगता है कि इसकी स्पष्टता आकर्षण का हिस्सा है।

Answer 14

बैच, 90 बाइट्स

 :: :::@:
:&s ohce@
:e   : c:
      :h:
:o     o:
:h:
:c :   w:
@echo n&:
:@::: ::

बैच वास्तव में एक टिप्पणी चरित्र नहीं है। पूरी-लाइन टिप्पणियों के लिए, :काम करता है, क्योंकि यह एक लेबल का परिचय देता है, लेकिन मुझे अभी भी कुछ echoउल्टा होने पर नो-ऑप होने के दौरान कमांड को समाप्त करने के लिए कुछ चाहिए । &:काम करने लगता है, जो मुझे यहां चाहिए, लेकिन यह वास्तव में बैच को भ्रमित करता है, अगर मैं अगली पंक्ति पर :पहले नहीं डालता हूं @, और यह भी किसी तरह से एक नई रूपरेखा प्रिंट करना भूल जाता है।

Answer 15

MATLAB, 29 17 5 11 बाइट्स

यह महसूस करने के बाद कि एकल ASCII वर्णों के लिए बुलाए गए प्रश्न न केवल एक अलग आउटपुट है, यहाँ एक MATLAB दृष्टिकोण है जो कि बस इतना ही करेगा:

%4%
1%3
%2%

यह रोटेशन के आधार पर 1, 2, 3 या 4 प्रिंट करेगा।

Comments

यह सोचने के लिए आओ, यह MATL में भी काम करेगा। हालांकि, मेरी एक बाइट गिनती है।

— Sanchises

Answer 16

कार्डिनल , 20 17 12 11 बाइट्स

.$
Z%"
+$v

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

यह सब समय और कोई भी कार्डिनल में उत्तर दिया? यह पहला आउटपुट है 0।

पूर्व

 +Z.
 $%$
 v"

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

आउटपुट 1।

दक्षिण

v$+
"%Z
 $.

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

एक स्थान आउटपुट।

पश्चिम

 "v
$%$
.Z+

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

आउटपुट v।

Answer 17

SOGL V0.12 , 4 बाइट्स

5H
I

आउटपुट 1, यह यहाँ की कोशिश करो!

I5
 H

आउटपुट H, यह यहाँ की कोशिश करो!

 I
H5

आउटपुट 5, यह यहाँ की कोशिश करो!

H
5I

आउटपुट 6, यह यहाँ की कोशिश करो!

Comments

यदि इसमें एक स्थान है, तो यह 5 बाइट्स है।

— श्री एक्सकोडर

@ Mr.Xcoder OP ने टिप्पणियों में कहा कि आपको इसे पैड करने की आवश्यकता नहीं है

— dzaima

Answer 18

जेएस, 17 बी

//1//
2///4
//3//

आउटपुट:
उत्तर: २,
पूर्व: ३,
दक्षिण: ४,
पश्चिम: ०.३३३३३३३३३३३…।
(जैसा कि: 2, 3/1, 4, 1/3)

Comments

PPCG में आपका स्वागत है! मुझे नहीं लगता कि यह वैध है, क्योंकि गैर-आरईपीएल वातावरण में, संख्या प्रदर्शित नहीं होगी। (मैं वहाँ गलत हो सकता है)

— Zacharý

(जेएस के बाद आरईपीएल को जोड़ दें, तो मुझे लगता है कि यह ठीक है)

— ज़ाचारि

आउटपुट एक एकल मुद्रण योग्य ASCII वर्ण होना चाहिए, इसलिए मेरे MATLAB एक की तरह, यह अमान्य है।

— टॉम कारपेंटर

Answer 19

मुझे सच में क्षमा करना:

//0//
////
 1/2
/////
//3//

और 28 बी। और 0.5, 3, 2, 0 के रूप में आउटपुट।

Comments

PPCG में आपका स्वागत है! आपको एक हेडर में भाषा का नाम और बाइट काउंट डालना चाहिए। और यह एक स्निपेट है, न कि एक पूर्ण कार्यक्रम या एक फ़ंक्शन, जो मान्य नहीं है। (मैं गलत हो सकता है)

— Zacharý

@ जाकारी मुझे लगता है कि codegolf.meta.stackexchange.com/questions/7842/... का कहना है कि REPLs अनुमति दी जाती है

— SuperStormer

किसी भी तरह से, उन्हें यह निर्दिष्ट करना चाहिए कि यह एक जेएस आरईपीएल है।

— Zacharý

आउटपुट एक एकल मुद्रण योग्य ASCII वर्ण होना चाहिए, इसलिए मेरे MATLAB एक की तरह, यह अमान्य है।

— टॉम कारपेंटर

Answer 20

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

उत्तर के लिए आउटपुट 0, पूर्व के लिए 1, दक्षिण के लिए 2, और पश्चिम के लिए 3 है।

////  _//
////  =//
_=>0//>//
  ////1//
  // //
//3////
//>//2>=_
//=  ////
//_  ////

const source =
`////  _//
////  =//
_=>0//>//
  ////3//
  // //
//1////
//>//2>=_
//=  ////
//_  ////`;

function rotateTextCW(text) {
  const lines = text.split("\n");
  const maxLineLength = lines
    .map(line => line.length)
    .reduce((max, len) => Math.max(len, max), 0);
  const paddedLines = lines.map(line => line.padEnd(maxLineLength));
  const charGrid = paddedLines.map(line => line.split(""));
  const rotatedGrid = [...new Array(maxLineLength)]
    .map(v => new Array(charGrid.length));

  for (let i = 0; i < charGrid.length; i++) {
    for (let j = 0; j < charGrid[i].length; j++) {
      rotatedGrid[j][charGrid.length - i - 1] = charGrid[i][j];
    }
  }

  return rotatedGrid
    .map(chars => chars.join("").trimRight())
    .join("\n");
}

const orientations = ["North", "East", "South", "West"];
let rotatedSource = source;
let markup = "";

orientations.forEach(orientation => {
  const code = `<pre>${rotatedSource}</pre>`;
  const result = `<code>${eval(rotatedSource)()}</code>`;
  const row = `
    <td>${orientation}</td>
    <td>${code}</td>
    <td>${result}</td>`;
  markup += `<tr>${row}</tr>`;
  rotatedSource = rotateTextCW(rotatedSource);
});

document.querySelector("table tr:first-child")
  .parentNode
  .innerHTML += markup;

<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet" />
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>

<div class="container">
  <table class="table table-striped table-responsive">
    <tr>
      <th>Orientation</th>
      <th>Source</th>
      <th>Result</th>
    </tr>
  </table>
</div>

Answer 21

MATL , 11 बाइट्स

HxI
xFx
TxK

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

इसे MATL में शुरू करते हैं। मुख्य चुनौती यह है कि स्टैक खाली होने पर किसी फ़ंक्शन को इनपुट की आवश्यकता होने पर MATL विफल हो जाता है। शायद संशोधक के साथ चालाक कुछ पसंद X, Y, Zऔर &कम कुछ के लिए कर सकता है, लेकिन मैं एक उपयुक्त संयोजन नहीं पा सके।

स्पष्टीकरण: सभी वर्ण स्टैक पर एक पूर्णांक को धक्का देते हैं, और xउन सभी को हटाते हैं लेकिन अंतिम।

Answer 22

पर्ल, 49 बाइट्स

48 बाइट्स कोड + 1 के लिए -p ।

खाली इनपुट मानता है जो TIO का समर्थन नहीं करता है, इसलिए इसके स्थान पर एक नई पंक्ति जोड़ी जाती है और इसका उपयोग नहीं किया जाता है। प्रिंट्स एन , ई , एस , डब्ल्यू ।

# ####
#S= _$
#; W#
 $_=N#
#_ _#
#= $#
#E#
 ## #

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

Answer 23

सी (जीसीसी) , 120 बाइट्स

मुझे वेरिएंट के बीच अधिक तालमेल की उम्मीद थी।

//}=)f8 ///
// c{(7 ///
   ;rr; //}
        ;c=
78; /// r{)
f(r /// r(f
){r /// ;38
=c;
}// ;rr;
/// 9({c //
/// 6f)=}//

उत्तर

पूर्व

दक्षिण

पश्चिम