कार्य: एक इनपुट को वर्णों के बिल्कुल समाहित करते हुए <>^v, एक दूसरे इनपुट को प्रिंट करने योग्य ASCII वर्ण (स्पेस से टिल्ड तक) से युक्त, तीर के साथ उन्मुख आउटपुट।

मान लेते हैं कि प्रोग्राम का दूसरा इनपुट है ABC। यह वही है जो यह करना चाहिए:

इनपुट >: प्रिंट ABC।
इनपुट <: प्रिंट CBA।
इनपुट ^: प्रिंट C\nB\nA, या इनपुट घुमाया -90 °।
इनपुट v: प्रिंट A\nB\nC, या इनपुट 90 ° घुमाया गया।

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

input => \n output
---
">", "thanks!" =>
thanks!
---
"<", "Hello, World!" =>
!dlroW ,olleH
---
"^", "This is text." =>
.
t
x
e
t

s
i

s
i
h
T
---
"v", "Tokyo" =>
T
o
k
y
o
---
"<", ">>>" =>
>>>

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

code-golf string

— कोनोर ओ ब्रायन
स्रोत

पूर्ण कोड या फ़ंक्शन?

— हाइपरएनुट्रिनो

1

@AlexL। आप या तो afaik

— Downgoat

क्या इनपुट सभी एक स्ट्रिंग के रूप में ठीक है? >ABC

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

@DigitalTrauma हाँ, यह ठीक है।

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

नहीं, मैं समझ रहा हूं कि इससे कोई फर्क नहीं पड़ता। आपके पास >अभिविन्यास के लिए कोई परीक्षण मामला नहीं है ।

— mbomb007

14

MATL , 10 6 बाइट्स

मार्टिन को धन्यवाद देने से बच गए 4 बाइट!

19\qX!

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

19\            % implicitly take input (a character) and compute mod-19 of its ASCII code
   q           % subtract 1. Gives 17, 2, 3, 4 for the characters '^<v>' respectively.
               % These numbers correspond to 1, 2, 3, 4 modulo 4, and so are the numbers
               % of 90-degree rotations required by each character
    X!         % implicitly take input (string). Rotate the computed number of times
               % in steps of 90 degrees. Implicitly display

पुराने संस्करण, बिना मॉडुलो संचालन: 10 बाइट्स

'^<v>'=fX!

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

'^<v>'         % push string
      =        % implicitly take input (a char) and test for equality
       f       % find index of matching character
        X!     % implicitly take input (string). Rotate that number of times
               % in steps of 90 degrees. Implicitly display

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

1

अरे मैं वास्तव में अपने 13 बाइट्स पर गर्व था, लेकिन इनपुट के लिए 3 बाइट्स की जरूरत थी और घूर्णन के लिए 6 ... ओह अच्छी तरह से ... शायद आप भी mod 11चाल के साथ कुछ बचा सकते हैं (आपको दूसरे तरीके से चक्कर लगाना होगा हालांकि) ।

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

@ MartinBüttner अच्छा विचार है! मेरे मामले में (आप में?) मुझे लगता है कि मॉड 19 बेहतर है, क्योंकि तब 1 सीधे घटाना 1,2,3,4 (मॉड 4) देता है। पारितोषिक के लिए धन्यवाद!

— लुइस मेंडो

6

4 बाइट्स छोटी, धरती पर क्या ...

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

2

मैं आधिकारिक तौर पर MATL को "भाषा की सूची में डाल रहा हूं जो कि बहुत ही कम हैं।"

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

12

पायथन 3, 64 51 48 बाइट्स

सहेजे गए 6 बाइट्स xnor के लिए धन्यवाद।

लिन को धन्यवाद दिया 7 बाइट्स बचाए।

इतने अजगर से डीएसएम और मॉर्गन के लिए 3 बाइट्स को बचाया ।

lambda c,s:'\n'[c<'?':].join(s[::1|-(c in'<^')])

फ़ंक्शन <>^vपहले तर्क में से एक अक्षर को स्वीकार करता है और स्ट्रिंग को दूसरे तर्क के रूप में घुमाए जाने की आवश्यकता होती है।

यहाँ अधिक पठनीय संस्करण है:

lambda c, s: ('\n' if c in '^v' else '').join(s[::-1 if c in'<^' else 1])

— रिवाल्ट तिजोरी
स्रोत

PPCG में आपका स्वागत है! यदि यह मदद करता है, तो आपको दो अलग-अलग इनपुट लेने की अनुमति है। (मुझे अजगर का पता नहीं है, यह सिर्फ एक अनुमान है।)

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

हो सकता है कि s[1|-(c in'<^')]औरsep='\n'*(c in'^v')

— लिन

मुझे लगता है कि आप पूरे काम कर सकते हैं जैसे lambdaकि आप joinमुद्रण के बजाय अपने सेप के साथ उपयोग करते हैं।

— xnor

आपने इसे cw क्यों बनाया?

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

1

मुझे यह उत्तर पसंद है, यह मेरा पसंदीदा उत्तर है।

— बिल्ली

8

हास्केल, 57 बाइट्स

f">"=id
f"<"=reverse
f"v"=init.((:"\n")=<<)
f _=f"<".f"v"

प्रयोग उदाहरण: f "v" "ABC"-> "A\nB\nC"।

दिशा >, idendity समारोह है <यह की दलील को उलट देता है, vस्ट्रिंग में प्रत्येक चरित्र के लिए एक नई पंक्ति संलग्न कर देता है और पिछले एक चला जाता है और ^है vके बाद <।

— nimi
स्रोत

6

जाप, 9 बाइट्स

VzUc %B+1

@ DonMuesli के उत्तर से प्रेरित, हालांकि मैंने अभी देखा कि सीजेएम एक ही तकनीक का उपयोग करता है। इसे ऑनलाइन टेस्ट करें!

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

           // Implicit: U = arrow char, V = text
  Uc %B    // Take the char code of U, mod 11.
           // This converts ">", "v", "<", and "^" to 7, 8, 5, and 6, respectively.
Vz     +1  // Add one and rotate V by 90° clockwise that many times.

— ETHproductions
स्रोत

अच्छा काम! आपने 200% से अधिक ओफ़्फ़र्ड जोल्फ को उकसाया

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

लेकिन मुझे त्रुटियाँ मिल रही हैं? Error: Japt.stdout must be sent to an HTMLElementआदि

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

@ C @O'Bʀɪᴇɴ यकीन नहीं होता कि ऐसा क्यों होता है, लेकिन ऐसा बहुत होता है> :( रीलोडिंग हमेशा मेरे लिए यह तय करता है।

— ETHproductions

निश्चित रूप से, मुद्दा तय हो गया है। मैं प्रभावित हु!

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

मुझे पता था कि उन कार्यों को घुमाएगी अंततः उपयोगी होगा +1

— डाउगाट

4

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

l(iB%{W%z}*N*

इनपुट ओरिएंटेशन कैरेक्टर है जिसके बाद स्ट्रिंग को सीधे घुमाया जाता है।

इसका परीक्षण यहां करें।

व्याख्या

मोडुलो जादू के लिए याय। चार वर्णों के मॉडुलो को 11 मानचित्रों पर ले जा रहे हैं:

> 7 
v 8 
< 5
^ 6

ये सभी अलग-अलग मोडुलो 4 हैं और इससे भी महत्वपूर्ण बात यह है कि वे बड़े करीने से बढ़ रहे हैं 3, 0, 1, 2:। इसका मतलब है कि हम केवल mod 11यह निर्धारित करने के लिए परिणाम का उपयोग कर सकते हैं कि कितनी बार घूमना है (एक स्पष्ट आवश्यकता के बिना)mod 4 , क्योंकि चार घुमाव वैसे भी एक सेशन नहीं हैं)। हम आम तौर पर इन नंबरों को 1 से ऑफसेट करना चाहते हैं, जैसे कि >वास्तव में पैदावार 8और नो-ऑप बन जाता है, लेकिन जिस तरह से मैं उन्हें घुमा रहा हूं, वास्तव में पहले आवेदन पर स्ट्रिंग को उलट देता है, जैसे कि हम हमेशा मुफ्त में एक चक्कर लगाते हैं।

l    e# Read input.
(i   e# Pull off the first character and convert to its character code.
B%   e# Modulo 11.
{    e# That many times...
 W%  e#   Reverse... on the first iteration this reverses the string. Afterwards
     e#   we'll have an Nx1 or 1xN grid of characters on the stack, where
     e#   this reverses the rows instead.
 z   e#   Transpose. On the first iteration, this simply wraps the string in
     e#   array, turning it into a grid without changing its orientation further
     e#   beyond the reversal that just happened. On subsequent iterations, a
     e#   transpose combined with reversing the rows rotates the grid 90 degrees
     e#   clockwise.
}*
N*   e# Join with linefeeds.

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

4

Pyth, 17 15

jWgz\^_W}z"<^"w

इसे यहाँ आज़माएँ या चलाएँ टेस्ट सूट

2 बाइट्स ने जकुबे को धन्यवाद दिया!

वैकल्पिक रूप से मॉड ट्रिक्स का उपयोग करना:

@s_MBjBz)h%Cw11

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

— FryAmTheEggman
स्रोत

3

जूलिया, 51 बाइट्स

f(d,s)=join(d∈"<^"?reverse(s):s,d∈"^v"?"\n":"")

यह एक फ़ंक्शन है जो एक Charऔर एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है।

आज्ञा देना dचरित्र को दर्शाता है दिशा और sस्ट्रिंग हो। यदि dछोड़ दिया या ऊपर है, तो हम रिवर्स का उपयोग करते हैं s, अन्यथा हम sदिए गए अनुसार उपयोग करते हैं । हम एक स्ट्रिंगर का निर्माण खाली स्ट्रिंग के रूप में करते हैं यदि dबाएं या दाएं, या dऊपर या नीचे एक नई रेखा है । स्ट्रिंग और विभाजक को पास करेंjoin , जो स्ट्रिंग के प्रत्येक वर्ण के बीच विभाजक को सम्मिलित करेगा और एक स्ट्रिंग लौटाएगा।

सभी परीक्षण मामलों को ऑनलाइन सत्यापित करें

— एलेक्स ए।
स्रोत

3

बैश + जीएनयू यूटिलिटीज, 67

(egrep -q '>|v'<<<$1&&cat||rev)|(egrep -q '<|>'<<<$1&&cat||fold -1)

— डिजिटल आघात
स्रोत

मुझे अनुमान नहीं था कि आपको एक जगह की जरूरत है -q, लेकिन आप करते हैं

— बिल्ली

3

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

(a,b)=>(/v|>/.test(a)?[...b]:[...b].reverse()).join(a>`>`?`
`:``)

पोर्ट ऑफ @ एलेक्स जूलिया जवाब। संपादित करें: @ ब्युरोग के लिए 9 बाइट्स को सहेजा गया। @ Edc65 के लिए अलग से दो बाइट्स सहेजे गए।

— नील
स्रोत

/[v^]/.test(a)=>'Z'<a

— ETHproductions

+1? "रिवर्स": "स्लाइस" प्रतिभा

— edc65

@ edc65 वूप्स, मैंने गलती से एक पुराने संस्करण की नकल की; बोरिंग ?:संस्करण 1 बाइट छोटा था।

— नील

(/v|>/.test(a)?[...b]:[...b].reverse())...

— edc65

3

पर्ल, 54 51 + 1 = 52 बाइट्स

@.=<>=~/./g;@.=reverse@.if/[<^]/;$,=$/x/[v^]/;say@.

आवश्यक है -nझंडा और नि: शुल्क -M5.010| -E। निम्नलिखित के रूप में इनपुट लेता है direction\nline:

$ perl -nE'@.=<>=~/./g;@.=reverse@.if/[<^]/;$,=$/x/[v^]/;say@.' <<< $'^\nhello'
o
l
l
e
h

मुझे वह पसंद है $/x/[v^]/ जो एक प्रतिस्थापन की तरह दिखता है।

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

                                                    # -n read first line into $_
@.=<>=~/./g;                                        # Read next line and split
            @.=reverse@.if/[<^]/;                   # Reverse `@.` if matches 
                                                    # `<` or `^`
                                 $,=                # An array will be concatena-
                                                    # ted with the value of 
                                                    # `$,` when printed. 
                                     $/             # Contains a newline
                                        /[v^]/      # boolean 
                                       x            # "\n" x 1 -> "\n"
                                                    # "\n" x 0 -> ""
                                              say@. # Print the array

— andlrc
स्रोत

2

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

param([char]$a,$b)($b[($c=$b.length)..0],$b[0..$c])[$a%7-eq6]-join("","`n")[90-lt$a]

यह PowerShell से परिचित लोगों के लिए पूरी तरह से अस्पष्ट होने वाला है। इससे गुजरते हैं।

के लिए param([char]$a,$b)एक स्पष्ट कलाकारों के साथ इनपुट लेता है $a। कार्यक्रम के बाकी एक बयान है। हम पहली छमाही के साथ शुरू करेंगे -join।

हम एक नया डायनामिक ऐरे बना रहे हैं (...,...)और इसके साथ अनुक्रमण कर रहे हैं $a%7-eq6। ASCII मूल्यों के लिए vऔर >कर रहे हैं 116और 62क्रमश: और 116%7 = 62%7 = 6, और उन दो दिशाओं कि "वृद्धि" नीचे और सही करने के लिए कर रहे हैं। तो, अगर ऐसा -eqहै $true, तो हम दूसरा मान लेंगे, जो कि $b[0..$c], या अंत तक वर्णों की एक सरणी है$b । हमें $cपहले मूल्य से मूल्य मिलता है $b[($c=$b.length)..0], जो चयनित हो जाता है यदि इनपुट चार ^या <(यानी, तो यह स्ट्रिंग पीछे की ओर जाता है)। ध्यान देना महत्वपूर्ण है कि भले ही दूसरा मूल्य चुना $cजाता है, फिर भी मूल्य की गणना और संग्रहित किया जाता है, इसलिए हम इसे शॉर्टकट के रूप में फिर से उपयोग कर सकते हैं।

इसलिए, हमें अब वर्णों की एक सरणी मिल गई है जो या तो आगे या पीछे की ओर जा रही है। हम फिर -joinएक और गतिशील सरणी सूचकांक के परिणाम के साथ उन वर्णों को एक साथ करते हैं। इस बार हम इस आधार पर चयन कर रहे हैं कि क्या ASCII मूल्य $aनीचे है 90(वास्तव में बहुत सारे मान काम करेंगे, मैंने इसे सिर्फ इसलिए चुना है)। के बाद से >और <दोनों नीचे एक मूल्य है 90, -ltहै $false, तो हम खाली स्ट्रिंग का चयन "", और इस तरह चार-सरणी बस concatenated है। अन्यथा, हम नए वर्णों के "`n"साथ वर्ण-सरणी में शामिल होने के लिए नए वर्ण का चयन करते हैं ।

इस परिणामी स्ट्रिंग को पाइप लाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\orthogonal-orientation.ps1 "^" "TimmyD"
D
y
m
m
i
T

— AdmBorkBork
स्रोत

2

सी, 123 119 117 114 बाइट्स

golfed:

f(char*d,char*a){char*b=a,c=*d%21,s[3]={0,c&8?10:0};while(*++b);while(*s=c&4?*a++:*--b)printf(s);if(c&16)puts(b);}

परीक्षण कार्यक्रम, स्पष्टीकरण और कुछ हद तक असंयमित कोड के साथ:

#include <stdio.h>
#include <stdlib.h>

// c     c%21   
// <    10010     => if(c&8), vertical; if(c&16), horizontal
// >    10100     => if(c&4), backwards
// ^    01010
// v    01101
int f(char*d,char*a){
    char *b=a,c=*d%21,s[3]={0,c&8?10:0};
    while(*++b);     // b = a + strlen(a) - 1; this is shorter
    while(*s=c&4?*a++:*--b)printf(s);
    if(c&16)puts(b); // single trailing newline if horizontal
}

int main() {
    char *c="<>^v";
    for(;*c;c++) { 
        printf("--- %c ---\n", *c); 
        f(c,"hello world!"); 
    }
    return 0;
}

टिप्स का स्वागत है!

— tucuxi
स्रोत

2

रेटिना , 60 बाइट्स

गोल्फ की जरूरत है ...

$
¶
+`^([<^].*)(.)(¶.*)
$1$3$2
¶

.
$&¶
+`([<>].*)¶
$1
^.¶?

इनपुट सभी एक स्ट्रिंग के रूप में है, उदाहरण के लिए ^ABC।

यदि ^या <, स्ट्रिंग को उल्टा करें
हर किरदार के बाद नई सुर्खियाँ डालें
यदि <या >, नए सिरे को हटा दें

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

— डिजिटल आघात
स्रोत

retina.tryitonline.net/… एक बाइट बचाता है (और अतिरिक्त अनुगामी लाइनफीड से छुटकारा पाता है)

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

2

दिल्लोग एपीएल , 15 बाइट्स

⌽∘⍉⍣(11|⎕UCS⍞)⍪

⍪1-स्तंभ तालिका में मेकअप स्ट्रिंग
⍣(‍... )दोहराने ( एन ) बार ⍞स्ट्रिंग इनपुट मिल
⎕UCSपरिवर्तित यूसीएस कोड बात करने के लिए
11|विभाजन बाकी जब 11 से विभाजित
⌽∘⍉ रोट -90 ° (फ्लिप-ट्रांसपोज़) से

वैकल्पिक विधि (एक ही लंबाई):

⌽∘⍉⍣('<^>v'⍳⎕)⍪

⎕मूल्यांकन किए गए इनपुट प्राप्त करें (इसलिए किसी को इनपुट करना होगा, जैसे '^' या एक प्रोग्राम / चर का नाम जो वांछित वर्ण लौटाता है)
'<^>v'⍳अनुक्रमणिका में

— एडम
स्रोत

1

जोल्फ, 22 बाइट्स

यहाँ कोशिश करो! आप के ƒसाथ प्रतिस्थापित करना चाहिए \x9f। स्टिंग लेता है, तो दिशात्मक चरित्र।

.‘I_IγƒGIE_γ’ i"><v^"i
 ‘                      golfy array
  I                     the input
   _I                   input reversed
      ƒGIE              split by "" and join by newlines
     γ                  γ = that
          _γ            gamma reversed
.            _i"><v^"i  get the respective index

— कोनोर ओ ब्रायन
स्रोत

1

जावास्क्रिप्ट ईएस 6, 91 83 84 बाइट्स

(a,b)=>[b,(c=[...b].reverse()).join``,[...b].join`
`,c.join`
`]["><v^".indexOf‌(a)]

आवश्यक तारों का निर्माण करता है और इनमें aसे सूचकांक प्राप्त करता है, जिसका indexOfउपयोग किया जाता है क्योंकि ^रेगेक्स टोकन है। बग फिक्स और मुंडा बाइट्स के लिए ETHproductions का धन्यवाद!

— कोनोर ओ ब्रायन
स्रोत

f("v","abc")c\nb\naमेरे लिए लौटता है।

— ETHproductions

यहाँ एक 84-बाइट है जो मेरे लिए काम करता है:(a,b)=>[b,(c=[...b].reverse()).join``,[...b].join`\n`,c.join`\n`]["><v^".indexOf(a)]

— ETHproductions

@ETHproductions धन्यवाद! मैं cसचमुच भूल गया हूं d।

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

ब्याज से बाहर मैंने एक वस्तु को अनुक्रमित करने की कोशिश की ... और यह बिल्कुल समान लंबाई की हो गई!

— नील

1

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

(a,b)=>([...b].map(c=>(a>'A'?c+=`
`:0,r=/v|>/.test(a)?r+c:c+r),r=''),r)

परीक्षा

F=(a,b)=>([...b].map(c=>(a>'A'?c+=`
`:0,r=/v|>/.test(a)?r+c:c+r),r=''),r)  

console.log=x=>O.textContent+=x+'\n';

for(d of '<>^v') console.log(d+'\n'+F(d,'ABCDE')+'\n')

<pre id=O></pre>

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

— edc65
स्रोत

1

पर्ल 5, 67 बाइट्स

66 प्लस एक के लिए -p

$_=reverse if/^[<^]/;$&?s/.$//:s/.//;$&=~/[v^]/&&s/(.)(?=.)/$1\n/g

इनपुट एकल स्ट्रिंग है जिसका पहला वर्ण अभिविन्यास परिभाषित करता है।

— msh210
स्रोत

1

डीयूपी , 48 बाइट्स

[`5/%$$a:4<&[1$][1_]?\1-[$;$][,^+a;2>['
,][]?]#]

Try it here.

अनाम लंबोदर जो तर्क और STDIN इनपुट दोनों लेता है। उपयोग:

0"asdf"[`5/%$$a:4<&[1$][1_]?\1-[$;$][,^+a;2>['
,][]?]#]! {make sure to put one of <>^v in STDIN}

व्याख्या

[                                               ] {lambda}
 `5/%$$a:                                         {store STDIN char (mod 5) to a}
         4<&                                      {is 0<a<4?}
            [  ][  ]?                             {conditional}
             1$                                     {if so, push 2 1's}
                 1_                                 {otherwise, push -1}
                                                    {determines whether to output in reverse or not}
                     \1-                          {swap, -1}
                        [   ][                ]#  {while loop}
                         $;$                        {if there is a char at index}
                              ,                     {output that char}
                               ^+                   {increment/decrement index}
                                 a;2>               {check if a>2}
                                     [    ][]?      {conditional}
                                      '\n,          {if so, output newline}

— मामा फन रोल
स्रोत

1

गंभीरता से, 41 बाइट्स

,' 9uc#;+"? R #'{}j #R'{}j"fs,"><v^"í@E£ƒ

पहले इनपुट और दिशा के रूप में स्ट्रिंग लेता है (><v^ ) को दूसरे इनपुट के रूप में ।

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

— मै जाऊं
स्रोत

1

डी, 198 बाइट्स

import std.stdio,std.array,std.algorithm;void main(string[]a){auto x=a[2].split("");char[]y;if(canFind(["^","<"],a[1]))x.reverse;if(canFind(["v","^"],a[1]))y=x.join("\n");else y=x.join("");y.write;}

:सी

कम गोल्फ वाला:

import std.stdio;
import std.array;
import std.algorithm;

void main(string[]a) {

  auto x=a[2].split("");
  string y;

  if(canFind(["^","<"],a[1]))
    x.reverse;

  if(canFind(["v","^"], a[1]))
    y=join(x,"\n");

  else
    y=join(x,"");

  y.write;
}

— बिल्ली
स्रोत

ऑर्थोगोनल ओरिएंटेशन

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

MATL , 10 6 बाइट्स

पायथन 3, 64 51 48 बाइट्स

हास्केल, 57 बाइट्स

जाप, 9 बाइट्स

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

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

व्याख्या

Pyth, 17 15

जूलिया, 51 बाइट्स

बैश + जीएनयू यूटिलिटीज, 67

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

पर्ल, 54 51 + 1 = 52 बाइट्स

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

सी, 123 119 117 114 बाइट्स

रेटिना , 60 बाइट्स

दिल्लोग एपीएल , 15 बाइट्स

जोल्फ, 22 बाइट्स

जावास्क्रिप्ट ईएस 6, 91 83 84 बाइट्स

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

पर्ल 5, 67 बाइट्स

डीयूपी , 48 बाइट्स

व्याख्या

गंभीरता से, 41 बाइट्स

डी, 198 बाइट्स