रिप बंद एक की नकल बंद एक की नकल बंद एक की नकल बंद । उन ऊपर जाओ!

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

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

चूंकि यह कोड-गोल्फ है , लक्ष्य मूल स्रोत कोड (ट्रांसपोज़्ड संस्करण नहीं) की बाइट गणना को अनुकूलित करना है।

उदाहरण

मान लीजिए कि आपका समाधान एक संख्यात्मक मैट्रिक्स लेता है और आपका स्रोत कोड है

AB
DEF

और उसके इनपुट / तर्क है [[1,2],[3,4],[5,6]]। अगर मैं लिखता

AD
BE
 F

इसके बजाय और इसे चलाएं, आउटपुट / परिणाम होना चाहिए [[1,3,5],[2,4,6]]।

मान लीजिए कि आपका समाधान एक पंक्ति-अलग-अलग स्ट्रिंग लेता है और आपका स्रोत कोड है

ABC

और उसके इनपुट / तर्क है "96\n"। अगर मैं लिखता

A
B
C

इसके बजाय और इसे चलाएं, आउटपुट / परिणाम होना चाहिए "9\n6\n"।

code-golf matrix source-layout

— एडम
स्रोत

23

हे भगवान। क्या हम रुक सकते हैं?

— JL2210

3

@ रात 2 नहीं, यह मामलों को जटिल बनाता है।

— 16

14

@ JL2210 नहीं, मेरे पास कामों में एक बड़ा है।

— आदम

7

गंभीर टिप्पणी के बिना प्रक्रियात्मक भाषाओं में ये चुनौतियां असंभव हैं।

— JL2210

2

@ JL2210 ट्रांसफ़ॉर्म ।

— आडंबर

27

पायथन 3 + सुन्न, 45 बाइट्स

lambda\
a:a
ma= """
b.    "
dT"   "
a "
\ """

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

@EriktheOutgolfer की ओर से पिछले संस्करण के एक बग को इंगित करते हुए धन्यवाद

पक्षांतरित:

lambda\
a:a.T  
ma= """
b     "
d "   "
a "    
\ """

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

फ़ंक्शन इनपुट के रूप में एक संख्यात्मक मैट्रिक्स लेते हैं और एक संख्यात्मक मैट्रिक्स का उत्पादन करते हैं। समाधान कई अन्य समाधानों की तरह टिप्पणियों पर निर्भर नहीं करता है, बल्कि बहु-पंक्ति तारों का फायदा उठाता है।

— जोएल
स्रोत

3

यह वास्तव में साफ है!

— एडम

हम्म, मुझे पूरा यकीन है कि ट्रांसपोज़्ड संस्करण को रिक्त स्थान के साथ गद्देदार किया जाएगा, इसलिए अंतिम पंक्ति में अनुगामी रिक्त स्थान होंगे, इसलिए यह \एक फेंक देगा SyntaxError। इसे ठीक करने के लिए आपको उद्धरण को दोनों दिशाओं में ले जाने की आवश्यकता है।

— आउटगॉल्फ

@EriktheOutgolfer फिक्स्ड। धन्यवाद।

— जोएल

15

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

इनपुट सूची की एक सूची है। उत्तर को बेहतर बनाने के लिए लुइस मेंडो और निक केनेडी का धन्यवाद।

ZZ

इसे ऑनलाइन आज़माएं! इसे ट्रांसपोज़ करने की कोशिश करो!

कार्यक्रम दो बार इनपुट को स्थानांतरित करता है, मूल इनपुट लौटाता है। प्रत्यारोपित संस्करण पहली पंक्ति को अनदेखा करता है और केवल एक बार ही स्थानांतरित होता है।

— OVS
स्रोत

13

आर , 5 4 बाइट्स

#t
I

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

एक आर फ़ंक्शन, या तो पहचान फ़ंक्शन Iया ट्रांसपोज़ किए गए फ़ंक्शन को स्थानांतरित करता tहै। TIO पर पाद दोनों का आउटपुट दिखाता है।

एक बाइट को बचाने के लिए @RobinRyder का धन्यवाद!

— निक केनेडी
स्रोत

आपको अंतिम की आवश्यकता नहीं है #।

— रॉबिन राइडर

@RobinRyder धन्यवाद! किसी कारण से मैं एक आयत में गद्दी पर बैठा था, भले ही मैंने बयान देखा था कि यह अनावश्यक था।

— निक कैनेडी

10

सी (जीसीसी) , 209 205 203 201 बाइट्स

साधारण

f(n,L,r,c)char**L;{for(c=0;0?L+  c:c<n;c+=puts(""))for(r=0;0?r :L[c][r];r++)putchar(L[ c ][ r ]);}/*
          \\\      \\      1 [0][]      \ \\\  \   \\      1 <n          \  \\\\\\   r+-c c+-r    */

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

पक्षांतरित

f 
( 
n 
, 
L 
, 
r 
, 
c 
) 
c\
h\
a\
r 
* 
* 
L 
; 
{ 
f\
o\
r 
( 
c 
= 
0 
; 
01
? 
L[
+0
 ]
 [
c]
: 
c 
< 
n 
; 
c 
+\
= 
p\
u\
t\
s 
( 
"\
" 
) 
) 
f\
o\
r 
( 
r 
= 
0 
; 
01
? 
r<
 n
: 
L 
[ 
c 
] 
[ 
r 
] 
; 
r 
+\
+ 
) 
p\
u\
t\
c\
h\
a\
r 
( 
L 
[r
 +
c-
 c
] 
[c
 +
r-
 r
] 
) 
; 
} 
/*
*/

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

— gastropner
स्रोत

8

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

यह संस्करण मान्य है, लेकिन []इनपुट के रूप में दिए जाने पर रुकेगा नहीं ।

f
--(:[|,<zabf=]f
--abx(y-i$]
-- ):x) pf;x[:x
 y =y

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

ट्रांसपोज़्ड, 75 बाइट्स

f---
 ---y
 (a
 :b)=
 [x:y
 |(x
 ,y)
 <-
 zip
 a$f
 b];
 f x
 = [
 ] :
 f x

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

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

यह संस्करण मान्य है, लेकिन []ट्रांसपोज़्ड संस्करण के लिए इनपुट के साथ क्रैश हो जाता है।

f
--d[(idi)z[.]d!0
-- m!)|,<i0.$ !]
-- a! (_-p
 p=p

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

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

कम से कम 7 बाइट्स ने अर्जन जोहान्सन को धन्यवाद दिया

इनपुट के रूप में []दिए जाने पर यह संस्करण आउटपुट []करता है।

f
--[[d(i<di)z[.$!0
--]]=!)$|,<i0.d!]
-- ;[! >(_-p ]
 f=f

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

पक्षांतरित

— गेहूं का जादूगर
स्रोत

60 बाइट्स

— अर्जन जोहानसन

@ ØrjanJohansen धन्यवाद! मैंने पहले भी ऐसा कुछ करने की कोशिश की थी, लेकिन मैं इसे काम नहीं कर पाया। अपने 60 से 3 अधिक बाइट्स लेने का एक बहुत आसान तरीका है।

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

7

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

lambda\
a:a
mz= '''
bi'   '
dp'   '
a('
 *
 a
\)'''

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

जोएल के दृष्टिकोण के आधार पर । इनपुट एक tupleका है tuple, और आउटपुट एक है zip( tupleबेहतर दृश्यता के लिए एक ओवर टीआईओ में परिवर्तित )।

पक्षांतरित:

lambda  \
a:zip(*a)
ma='''  '
b       '
d '     '
a '      
\ '''

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

— आउटगोल्फर को एरिक करें
स्रोत

5

पर्ल 6 , 20 11 बाइट्स

#&
*[
#Z
 ]

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

पक्षांतरित

#*# 
&[Z]

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

दोनों कार्य सूचियों की सूची पर काम करते हैं।

*[ ] जो भी कोड अपने तर्क के ज़ेन स्लाइस को वापस कर रहा है, प्रभावी रूप से पहचान समारोह।

&[Z] ज़िप ऑपरेटर है।

— nwellnhof
स्रोत

5

हास्केल, 185 161 बाइट्स

t i
 =
 i
af

 n m
 u a e i
 l p s d
 lu h=u
 (
 h
 e
 a
 d

 a
 )
 t
 h
 e
 n
 [
 ]
 e
 l
 s
 e

 m
 a
 p

 h
 e
 a
 d

 a
 :
 t
 (
 m
 a
 p

 t
 a
 i
 l

 a
 )

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

पक्षांतरित:

t  a
 =if null(head a)then[]else map head a:t(map tail a)
i       u
     map
        h
      es=
        u
      id

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

कोई टिप्पणी नहीं, कोई स्ट्रिंग शाब्दिक नहीं, बस कुछ अतिरिक्त फ़ंक्शन परिभाषाएं।

संपादित करें: -24 बाइट्स @ अर्जन जोहान्स को धन्यवाद।

— nimi
स्रोत

2

161 बाइट्स

— अर्जन जोहानसन

4

PHP (7.4), 114 86 70 बाइट्स

PHP में मेरा ऐसा अनुभव करने का मेरा पहला अनुभव है, एक बेहतर तरीका होना चाहिए जो मैं नहीं देख सकता! इनपुट ऐरे की तरह है [[1,2],[3,4],[5,6]]।

सामान्य:

fn($a)=>$a/*
nu         /
(l
$l
a,
).
=.
>.
a$
ra
r)
a/
y*
_
m
a
p
(*/

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

ट्रांसपोज़्ड (अंतरिक्ष गद्देदार):

fn($a)=>array_map(
null,...$a)/*    *
(                /
$                 
a                 
)                 
=                 
>                 
$                 
a                 
/                 
*/

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

— Night2
स्रोत

3

चारकोल , 19 बाइट्स

Ａ¿⁰«
‖⁰¿
↗⁰
¿⁰
⁰¿
«

इसे ऑनलाइन आज़माएं! स्ट्रिंग के एक सरणी के रूप में इनपुट लेता है। स्पष्टीकरण: Ａस्पष्ट रूप से स्पष्ट इनपुट प्रिंट करता है, जबकि ¿⁰एक शर्त है, 0इस शर्त के साथ, जो इसलिए हमेशा झूठी होती है। «तब व्यर्थ चारकोल कोड का एक ब्लॉक शुरू होता है जो कभी निष्पादित नहीं होता है। (उन बाइट्स में से कुछ को हटाना संभव हो सकता है लेकिन उस स्थिति में मुझे यकीन नहीं है कि चारकोल कार्यक्रम को सही ढंग से पार्स करेगा।) ट्रांसपोज़्ड, 17 बाइट्स:

Ａ‖↗¿⁰«
¿⁰⁰⁰¿
⁰¿
«

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: पिछले प्रोग्राम के समान ही, ट्रांसपोज़ कमांड के अलावा को छोड़कर ‖↗।

मेरे पास एक वैकल्पिक समाधान है जहां मूल और ट्रांसपोज़्ड प्रोग्राम दोनों 18 बाइट्स हैं:

Ａ⊞υ”y
‖υ⁺y
↗⁺
⊞⁺
υ

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: Ａऊपर के रूप में; ⊞υएक मान को पूर्वनिर्धारित खाली सूची में धकेलता है (जो आउटपुट को प्रभावित नहीं करता है); ”yएक मनमाना स्ट्रिंग शुरू होता है (कार्यक्रम या मिलान के अंत में समाप्त होता है ”)। पक्षांतरित:

Ａ‖↗⊞υ
⊞υ⁺⁺
υ⁺
”y
y

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: Ａ‖↗ऊपर के रूप में; ⊞υऊपरोक्त अनुसार; यहाँ मामूली अंतर यह है कि मैं छोटे तारों के संघात पर जोर दे रहा हूँ, क्योंकि मैं इसे दोहराना नहीं चाहता ”।

— नील
स्रोत

3

ब्रेन-फ्लैक (ब्रेनहैक) , 382 375 337 बाइट्स

कोई टिप्पणी नहीं!

  ( <( <>)<> ><>) ({})  {}{}   {( )()<({}<{}<><>>{}<><>{}) ( <>) ({}<><( [ ]({}<{}( )<({}()<{}<><>>){} ><><{}<< ><> ( [ ]( <>)<>)>{}<>>>)){}>)> ( ){ {}[]} <>[]{
(({}({}  ( ))   <>( ))[( [ ])])({}[ ] [ ](   )  (   ) < ><>{}  <>(   ){{}()<( )( ({} {  [ ](   )   } <>)  (  (())  {{}()<{}    >}  )  ) >}    )}[] {} ( ){} ( ){}({}<>)<>([])}<>

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

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

पक्षांतरित

ब्रेन-फ्लैक (ब्रेनहैक) , 465 बाइट्स

 (
 (
({
 }
<(
({
 }
<
>
)(
<
>)
 )
>
<
>
)<
 >
((
{
})
))
 [
 (
{
}[
{
}]
 )
 ]
 )
{(
({
 }
)[
(
)]
<
([
{
}]
<( 
{
}
<
>)
<
>
>(
{
}
<
>)
<
><
{
}>
)<
 >
({
 }
<
>
)<
 >
((
{
}
<
>)
<{
({
 }
[(
 )
]<
((
{
})
<(
{
}(
({
 }
)
<{
(
{
}[
(
)]
<(
{
}
<
>)
<
>
> 
)}
{
}<
 >
>)
<
>
<(
{
}
<(
<(
 )
>)
<
>
 {
({
 }
[(
 )
]<
({
 }
<
>
)
<
>>
)}
>
{
})
<
>
>)
>
)>
)}
{
}
>
)
>)
 }
([
 ]
)
{{
 }
{
}(
[
])
}{
 }
<
>(
[
])
{{
 }
 (
 {
 }
 <
 >
 )
 <
 >
 (
 [
 ]
 )
 }
 <
 >

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

— गेहूं का जादूगर
स्रोत

3

जाप , 2 बाइट्स

ÕU

कोशिश करो | पक्षांतरित

ÕU     :Implicit input of string/array U
Õ      :Transpose U
 U     :Original U
       :Implicit output

Õ\nU     :Implicit input of string/array U
Õ        :Transpose U
 \n      :Reassign to U
   U     :Newly transposed U
         :Implicit output

— झबरा
स्रोत

2

जावास्क्रिप्ट (Node.js) , 62 बाइट्स

//m0()m  ]
//=](=a  )
//>.a>p( )
//mm,m/aa
//[ap./=[
   p  =>p

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

एक अलग लेआउट के साथ सुधार हुआ

///// 
///// 
m=>m[ 
0].map 
((a,p 
)=>m. 
map//= 
  (a=> 
   a[p 
]))

— AZTECCO
स्रोत

2

हास्केल ,153 144 बाइट्स

(धन्यवाद, श्रीकोटिलिज्म ओ'जैसिक )

f
 [
 ]=
   [
   ];
    f(
     x:
      l)
       =(
        :)
         x l
-- :   z $
-- f   i f
-- [   p
-- ]   W
--     i
--     t
--     h

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

इसे ट्रांसपोज़ करने की कोशिश करो!

— काउंटरक्लॉक को चालू करना बंद कर दिया
स्रोत

यहां आपकी संरचना को बनाए रखते हुए 144 बाइट संस्करण है। ( प्रत्यारोपित )।

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

यहाँ एक 70 बाइट संस्करण है जो अभी भी समान है लेकिन कुछ संरचनात्मक परिवर्तनों के साथ। ( प्रत्यारोपित )।

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

धन्यवाद। दूसरे संस्करण में केंद्रीय विचार का अभाव है (फिर से foldrदोनों संस्करणों के लिए पुन: उपयोग कर रहे हैं), यह पसंद नहीं है।

— काउंटरक्लॉविस

आप जानते हैं, यह चुनौती और आपका उपयोगकर्ता नाम एक दूसरे के प्रति विरोधाभासी है, क्योंकि आपके कोड ने ट्रांसपोज़्ड संस्करण में वामावर्त बदल दिया था। ; पी

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

2

एपीएल (डायलॉग यूनिकोड) , 7 बाइट्स

{⍵
⍉
⍵}

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

पक्षांतरित:

{⍉⍵
⍵ }

शायद एक उबाऊ जवाब है, लेकिन वैसे भी यहाँ जाता है।

इनलाइन फ़ंक्शन परिभाषा {...} को कई पंक्तियों अवधि कर सकते हैं। इस स्थिति में, प्रत्येक पंक्ति को क्रमिक रूप से निष्पादित किया जाता है, लेकिन बिना असाइनमेंट के कोई भी रेखा ←तुरंत अपने गणना मूल्य को वापस कर देती है। तो पहला फंक्शन लौटता है⍵ जबकि दूसरा रिटर्न⍉⍵ ।

अधिक उबाऊ उत्तर भी टिप्पणी का दुरुपयोग होगा:

एपीएल (डायलॉग यूनिकोड) , 4 बाइट्स

⍝⍉
⊢

कोई TIO आवश्यक नहीं है, मुझे लगता है ...

— bubbler
स्रोत

1

05AB1E , 3 बाइट्स

øø
q

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

øq
ø

इसे ट्रान्सपोज्ड करें।

स्पष्टीकरण:

अन्य भाषाओं में से कुछ के विपरीत, newlines को केवल 05AB1E में अनदेखा किया जाता है, इसलिए मुझे नहीं लगता कि 2-बायटर संभव है (हालांकि मैं गलत साबित होना पसंद करूंगा)।

ø    # Transpose the (implicit) input
 ø   # Transpose it back
  q  # Stop the program (and output the top of the stack implicitly as result)

ø    # Transpose the (implicit) input
 q   # Stop the program (and output the top of the stack implicitly as result)
  ø  # No-op, since the program has already stopped

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

1

रूबी , 35 बाइट्स

#-sz##
->hip{
 hip  }
#{f
#ht*
#..h

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

हिप टू बी स्क्वेयर! (लगभग)

इनपुट के रूप में रूबी मेट्रिक्स को स्वीकार करता है (सरणियों का सारणी)

— जीबी
स्रोत

1

साफ , 64 बाइट्स

//i$
//mp
$ p=p
//ot
//rr
//ta
// n
//Ss
//tp
//do
//Ls
//ie
//b

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

//$//////////
// //////////
import StdLib
$p=transpose
  p

इसे ट्रांसपोज़ करने की कोशिश करो!

— Οurous
स्रोत

0

अजगर 3 , 118 95 बाइट्स

इनपुट और परिणाम ट्यूपल्स की सूची है।

f=lambda i:i;"""
=              "
l              "
a
m
b
d
a

i
:
[
*
z
i
p
(
*
i
)
]
;
"
"
"""

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

— निशियोका
स्रोत

0

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 13 बाइट्स

#&(*
 *)
\

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

— attinat
स्रोत

0

Cjam , 13 बाइट्स

qo
~
z
`

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

ट्रांसपोज़्ड संस्करण:

q~z`
o

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

इनपुट प्रारूप

इनपुट प्रारूप मानक CJam सरणी प्रारूप है: [[1 2] [3 4]]

कोई क्रैश संस्करण, 12 बाइट्स

सरणी को प्रिंट करने के बाद सामान्य संस्करण क्रैश हो जाता है । एक संस्करण जो क्रैश नहीं होगा:

qo{
~
z
` };

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

या प्रत्यारोपित:

q~z`
o
{  };

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

शायद कुछ अतिरिक्त बाइट्स हैं जिन्हें बचाया जा सकता है, मैंने पहली बार ट्रांसपोज़्ड संस्करण पर काम किया, जिसके कारण कुछ अतिरिक्त लाइनब्रेक हुए और मुझे सीजेएम का उपयोग किए हुए एक लंबा समय हो गया। किसी भी सुधार का स्वागत करते हैं।

— रोमन ग्रैफ़
स्रोत

0

Zsh , 75 बाइट्स

  <<<${(F)@}
fa<
o[<
r+$
 +{
si(
;]F
i+)
==a
&$}
&s
r[
ei
p+
e1
a]
t

$
#
s

TIO: सामान्य ट्रांसपोज़्ड

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

ट्रांसपोंड संस्करण यहां है। इसे प्रिंट करने के बाद <एक पंक्ति के अंत में देखने में त्रुटि और बाहर निकलता है।

 for s;i=&&repeat $#s
 a[++i]+=$s[i+1]
<<<${(F)a}
<
<
$
{
(
F
)
@
}

— GammaFunction
स्रोत

0

रूनिक एनचेंमेंट्स , 88 बाइट्स

vrlril1-{)?\:',=4*?~r0[
i! '${U [0r/?*7̸0l{$
$ka6 ̹\!$,'/;? =  ̹
'              ̸

$

इसे ऑनलाइन आज़माएं!
इसे ट्रांसपोज़ करने की कोशिश करो!

इनपुट प्रत्येक मूल्य के लिए अलग जगह है और प्रत्येक पंक्ति के लिए अलग अल्पविराम (newlines वैकल्पिक हैं) और दोनों तार और (गैर-शून्य) संख्याओं का समर्थन करता है। यह इनपुट को आसान बनाता है क्योंकि इनपुट स्वचालित रूप से रिक्त स्थान और newlines द्वारा टूट जाता है। उदाहरण के लिए, इनपुट:

1 2 3 , 4 5 6 , 7 8 9

के रूप में नेस्टेड सरणी रूप में प्रतिनिधित्व किया जाएगा [[1,2,3],[4,5,6],[7,8,9]]। दांतेदार सरणियों के लिए न्यूनतम समर्थन (केवल अंतिम एक छोटा हो सकता है), लेकिन जैसा कि इनपुट आयताकार होने की उम्मीद है, यह उस आवश्यकता को पूरा करता है।

आउटपुट को एक ही प्रारूप में प्रस्तुत किया जाता है (नए संस्करण के साथ ट्रांसपोज़्ड संस्करण आउटपुट, लेकिन इसके स्थान का उपयोग करने के लिए इसके शून्य बाइट्स अलग हैं)। सामान्य संस्करण में एक अनुगामी स्थान होता है, संचरित संस्करण में अनुगामी अल्पविराम और नई रेखा होती है (जब प्रिंट करने के लिए अधिक डेटा नहीं होता है तो निर्धारण की कठिनाई के कारण)।

सामान्य संस्करण में अजीब स्थानों में संशोधक वर्ण होते हैं (जैसे। 7̸0 ) , लेकिन इसका कारण स्रोत के ट्रांसपोज़्ड होने पर सही जगह पर उनकी ज़रूरत होती है और सामान्य निष्पादन केवल निर्देशों के सबसे बाएं स्तंभ का उपयोग करता है।

व्याख्या

ट्रांसपोस्ड स्रोत की व्याख्या गैर-ट्रांसपोज़्ड रूप में होगी। तीर विभिन्न ब्लॉकों के प्रवेश और निकास पर आईपी दिशात्मकता का प्रतिनिधित्व करेगा।

→rlril1-{)?\:',≠4*?~r0[    Initial position. Read and parse input.
           ↓               Input loop exit and direction

इनपुट पढ़ा जाता है, और जब एक ,चरित्र पाया जाता है, तो एक नया सबटैक धकेल दिया जाता है। यह प्रत्येक स्टैक को स्मृति में प्रत्येक पंक्ति को अलग से रखने की अनुमति देता है। ऊपर से अगले भाग में प्रवेश करता है।

           ↓
.. '${̹L [0r/?*7≠0l{̹$       When no more input:
      ↑    ↓

[0(बाईं ओर निष्पादित) पहली पंक्ति और अंतिम पंक्ति के बीच एक सीमा के रूप में कार्य करने के लिए एक खाली स्टैक स्थापित करता है और फिर पहली स्टैक ( {̹) में घूमता है और मुद्रण तत्वों और स्टैक को घुमाने लगता है। i!निष्पादित नहीं है और {̹L [0rकेवल एक बार निष्पादित किया जाता है। जब एक शून्य-आकार का स्टैक पाया जाता है, तो लूप बाहर निकल जाता है।

      ↑    ↓
$ka6  \!$,'/;?             Row separation formatting

जब खाली-स्टैक पाया जाता है, तो एक ,और न्यूलाइन मुद्रित किया जाता है, और वैल्यू लूप को फिर से दर्ज किया जाता है। निष्पादन आदेश (पठनीयता के लिए आईना) जहां .एक गैर-निष्पादित कमांड है \',$!.6ak$?....../:। बदलने akके लिए '<space>नई-पंक्तियों के बजाय रिक्त स्थान मुद्रित होगा।

जब प्रोग्राम खाली स्टैक से लिखने का प्रयास करता है, तो एक्सेप्शन रुक जाता है; यही कारण है कि केवल अंतिम-पंक्ति का गुड़ सही ढंग से काम करता है और ,आउटपुट में एक अनुगामी क्यों है : प्रोग्राम को पता है कि कोई और डेटा नहीं है, इससे पहले ही अल्पविराम मुद्रित हो चुका है।

— Draco18s
स्रोत

मैं स्रोत कोड को स्थानांतरित करता हूं, आप इनपुट को स्थानांतरित करते हैं!

उदाहरण

पायथन 3 + सुन्न, 45 बाइट्स

पक्षांतरित:

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

आर , 5 4 बाइट्स

सी (जीसीसी) , 209 205 203 201 बाइट्स

साधारण

पक्षांतरित

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

ट्रांसपोज़्ड, 75 बाइट्स

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

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

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

पर्ल 6 , 20 11 बाइट्स

पक्षांतरित

हास्केल, 185 161 बाइट्स

PHP (7.4), 114 86 70 बाइट्स

सामान्य:

ट्रांसपोज़्ड (अंतरिक्ष गद्देदार):

चारकोल , 19 बाइट्स

ब्रेन-फ्लैक (ब्रेनहैक) , 382 375 337 बाइट्स

पक्षांतरित

ब्रेन-फ्लैक (ब्रेनहैक) , 465 बाइट्स

जाप , 2 बाइट्स

जावास्क्रिप्ट (Node.js) , 62 बाइट्स

हास्केल ,153 144 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 7 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 4 बाइट्स

05AB1E , 3 बाइट्स

रूबी , 35 बाइट्स

साफ , 64 बाइट्स

अजगर 3 , 118 95 बाइट्स

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 13 बाइट्स

Cjam , 13 बाइट्स

ट्रांसपोज़्ड संस्करण:

इनपुट प्रारूप

कोई क्रैश संस्करण, 12 बाइट्स

Zsh , 75 बाइट्स

रूनिक एनचेंमेंट्स , 88 बाइट्स

व्याख्या