34

किसी भी स्ट्रिंग को देखते हुए, इसे एक त्रिकोण के रूप में प्रिंट करें जहां पाठ प्रत्येक विकर्ण के साथ ऊपर और नीचे चलता है। उदाहरण के लिए, "Hello World"आउटपुट का एक इनपुट :

                    d
                  l  
                r   d
              o   l  
            W   r   d
              o   l  
        o   W   r   d
      l       o   l  
    l   o   W   r   d
  e   l       o   l  
H   l   o   W   r   d
  e   l       o   l  
    l   o   W   r   d
      l       o   l  
        o   W   r   d
              o   l  
            W   r   d
              o   l  
                r   d
                  l  
                    d

पंक्ति में प्रत्येक वर्ण के बीच का स्थान उचित प्रारूप बनाए रखने के लिए कम से कम 1 होना चाहिए।

code-golf string ascii-art code-golf string abstract-algebra code-golf ascii-art binary fractal code-golf array-manipulation sorting permutations code-golf code-generation code-golf sequence binary code-golf date code-golf array-manipulation restricted-source decision-problem primes code-golf multi-threading code-golf array-manipulation code-challenge decision-problem natural-language test-battery code-golf array-manipulation code-golf array-manipulation code-golf code-golf graph-theory

— मैकियावेली
स्रोत

1

क्या हम मान सकते हैं कि स्ट्रिंग खाली नहीं है?

— श्री Xcoder

@ Mr.Xcoder हाँ आप कर सकते हैं

— machiavelli

1

एक पंक्ति में प्रत्येक वर्ण के बीच का स्थान कम से कम 1 होना चाहिए : इसका मतलब यह है कि H l o W r dएक मान्य केंद्र पंक्ति है? यह पूछने पर कि आपके उदाहरण में प्रत्येक पंक्ति में प्रत्येक वर्ण के बीच 3 स्थान हैं।

— Emigna

1

@ ईमनिगा मैं आपको गलत समझा, मेरी क्षमायाचना। हां, आपका उदाहरण मान्य होगा।

— मचियावेल्ली

1

अग्रणी या अनुगामी रिक्त स्थान की अनुमति है?

— लुइस मेंडो

19

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

↗ＥＬθ✂θιＵＥ¹

~~इसे ऑनलाइन आज़माएं!~~ इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए हैं। स्पष्टीकरण:

    ↗       Print up and to the right
     ＥＬθ✂θι All suffixes of the input, as a list down and to the right
    ＵＥ¹     Insert blank columns

~~पहली बार मुझे ＵＥकमांड का उपयोग करने के लिए मिला ।~~

— नील
स्रोत

मुझे पता था कि चारकोल यहां पहले उत्तरों में से एक होगा .. जो खुद को शुरू करने के लिए लगभग ललचा रहा था, लेकिन मैं समय पर एक समाधान खत्म करने के लिए इसके साथ अनुभवहीन हूं, और यह वैसे भी बाहर हो जाएगा;)

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

6

@ इग्निना ... लेकिन यह मेरा उपयोग करने का बड़ा मौका था ＵＥ...

— नील

6

@EriktheOutgolfer ... लेकिन यह मेरा उपयोग करने का बड़ा मौका था ＵＥ..

— नील

1

@ नील यह -3 बाइट्स है! -3 एक अच्छे बलिदान के लिए! कौन कुछ अच्छा -3 नहीं चाहता है?

— को एग्री आउटफोलर

4

@EriktheOutgolfer आप क्या कहने वाले हैं, "आप 05AB1E को आपको हरा नहीं सकते, क्या आप कर सकते हैं?"

— नील

12

05AB1E , 10 8 7 बाइट्स

आभार एमिग्ना ने माना2 बाइट्स बचाने !

ðâƶ.cðζ

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

इस पंक्ति के अनुसार पंक्ति में प्रत्येक वर्ण के बीच का स्थान कम से कम 1 होना चाहिए जिसे आप निकाल सकते हैं ¶«। (ओपी के साथ वैधता का सत्यापन भी किया गया)

— एमिगा

@Emigna धन्यवाद! :)

— अदनान

Tio लिंक को अद्यतन करना चाह सकते हैं :)

— श्री Xcoder

@ Mr.Xcoder Ninja'd

— अदनान

1

चालाक का उपयोग करने âमें ðâके बजाय Sð«!

— आउटगॉल्फ

9

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

s=input()
k=l=len(s)
while k>1-l:k-=1;m=abs(k);print' '*m+' '.join(s[m::2])

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

रूड ने 3 बाइट्स बचाए।

— लिन
स्रोत

3

यह ओपी: 78 बाइट्स द्वारा अनुमति दी गई है । प्रत्येक पंक्ति पर स्थान कम से कम 1 होना चाहिए ।

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

1

75 बाइट्स

— अरफी

8

C, 86 78 73 70 वर्ण

for(int i=1,j=1-n;i=putchar(j*j<i*i&i-j?s[i-1]?:13:32)^13?i+1:++j<n;);

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

व्याख्या

Naive कार्यान्वयन: दो चक्र, ऊपर से नीचे तक भरें, दाएं से बाएं (99 बाइट):

for(int j=1;j<n*2;j++){for(int i=0;i<n;i++)printf("%c ",(i+j)%2&&i+1>=abs(j-n)?s[i]:' ');puts("");}

यहाँ, आउटपुट पर सिर्फ (प्रिंट) \ n डालता है। चलो चर घोषणाओं को जोड़ते हैं और j ++ को कुछ के साथ जोड़ते हैं (94 बाइट्स):

for(int i,j=0;++j<n*2;){for(i=0;i<n;i++)printf("%c ",(i+j)%2&&i>=abs(j-n)?s[i]:' ');puts("");}

अच्छा। परिवर्तनीय j की एक सीमा होती है 0 ... 2n; इसे एन के भीतर रहने दो ... n, यह गणित को सरल बनाता है। ध्यान दें कि & # के दाईं ओर बूलियन एक्सप्रेशन का मान हमेशा 0 या 1 होता है। इसका मतलब है कि हम & & को & से बदल सकते हैं। 91 बाइट:

for(int i,j=-n;++j<n;){for(i=0;i<n;i++)printf("%c ",~(i+j)%2&i>=abs(j)?s[i]:' ');puts("");}

और अब हमें एहसास हुआ कि हम एक अतिरिक्त जगह की छपाई कर रहे हैं। और हाँ, हमें केवल एक प्रतीक को प्रिंट करने के लिए प्रिंटफ () की आवश्यकता नहीं है। 86 बाइट्स:

for(int i,j=-n;++j<n;){for(i=0;i<n;i++)putchar(~(i+j)%2&i>=abs(j)?s[i]:' ');puts("");}

और भी बेहतर। ध्यान दें कि स्थिति i * i> = j * j समान है जैसे i> = abs (j), लेकिन छोटी। चलो लूप वृद्धि की अभिव्यक्ति के लिए पुट () में जाते हैं। और अंदाज लगाइये क्या? वास्तव में, मुझे i + j के आसपास ब्रेसिज़ की आवश्यकता नहीं है। 78 बाइट्स:

for(int i,j=-n;++j<n;puts(""))for(i=0;i<n;i++)putchar(i*i>=j*j&~i+j?s[i]:' ');

क्या आप जानते हैं कि पुचर () ने छपे हुए चरित्र को वापस लौटाया है? आइए समतुल्यता के लिए संख्याओं का परीक्षण करने के लिए XOR का उपयोग करें। आइए अंतरिक्ष को अपने ASCII कोड से बदलें, 32. याद रखें कि अंत-पंक्ति वर्ण कोड 13. है और अंत में: क्या आप जानते हैं कि GCC / Clang do https://en.wikipedia.org/wiki/Elvis_operator का समर्थन करते हैं ? 73 बाइट्स:

for(int i,j=-n;++j<n;)for(i=0;putchar(i*i>=j*j&~i+j?s[i]?:13:32)^13;i++);

अंत में, क्या लगता है? हमें दो छोरों की आवश्यकता नहीं है। हम बदसूरत ~ i + j को सिर्फ ij से बदल सकते हैं। 70 बाइट्स:

for(int i=1,j=1-n;i=putchar(j*j<i*i&i-j?s[i-1]?:13:32)^13?i+1:++j<n;);

भविष्य का काम: परिवर्तन लूप दिशा? यह कुछ बाइट्स को बचा सकता है, अगर ठीक से किया जाए।

— MrShoor
स्रोत

5

SOGL V0.12 , 13 10 9 बाइट्स

ēI*@∑}¹╚H

यह एक ऐसी सुविधा का उपयोग करता है जिसे मैंने अभी जोड़ा है , लेकिन कुछ समय पहले दस्तावेज किया गया था।

यहाँ यह कोशिश करो!
उस लिंक ,में जोड़ा जाता है क्योंकि यह स्टैक पर इनपुट की अपेक्षा करता है और {जोड़ा जाता है क्योंकि अन्यथा ,लूप में हर बार निष्पादित किया जाएगा

implicitly start loop over POP
ē            increase the variable E, on first push which will be 0
 I           increase by 1
  *          multiply the current character that many times
   @∑        join with spaces
     }     end loop
      ¹    wrap everything on stack in an array
       ╚   center vertically
        H  rotate counter-clockwise

— dzaima
स्रोत

4

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

f s|l<-length s-1=[zipWith min s$(' '<$[1..abs x])++cycle"~ "|x<-[-l..l]]

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

— लिन
स्रोत

3

गैया , 16 बाइट्स

$:ċ⟪×$§×⟫†€|$¦tụ

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

व्याख्या

$                 Split into list of chars
 :ċ               Push [1 .. len(input)]
   ⟪×$§×⟫†        Apply this block to corresponding elements of the two lists:
    ×              Repetition
     $             Split into chars
      §×           Join with spaces
          €|      Centre align the rows
            $¦    Split each line into chars
              t   Transpose
               ụ  Join each row with spaces, then join the rows together with newlines

— बिजनेस कैट
स्रोत

3

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

-3 ऑफिशियल धन्यवाद

lambda s,j=' '.join:map(j,zip(*(j(c*-~i).center(len(s)*2)for i,c in enumerate(s))))

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

— Arfie
स्रोत

1

83 बाइट्स

— आधिकारिक

3

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

;€⁶ṁ"JUz⁶ZUŒBZG

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

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

3

ऑक्टेव, 59 63 58 57 बाइट्स

@(s,a=@strjust)a([kron(+a(hankel(s)),[1 0;0 0]) '']',99)'

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

— rahnema1
स्रोत

1

99: अच्छा विचार :-)

— लुइस मेंडू

3

जावा, 292 बाइट्स (क्षमा करें)

public class D{
public static void main(String[]r){
String s=r[0];int L=s.length(),n=L*2-1,x=L-1,d=-1,i,j;boolean a=false,o=L%2==1;
for(i=0;i<n;i++){
for(j=0;j<L;j++)System.out.print(j<x||a&&j%2==(o?0:1)||!a&&j%2==(o?1:0)?' ':s.charAt(j));
System.out.println();
x+=d;if(x<0){x=0;d=1;}a=!a;}}}

— ubzack
स्रोत

1

आप नए सिरे से हटा सकते हैं, अन्यथा, यह बहुत गॉल्फर्ड दिखता है!

— ज़ाचरी

1

आप अधिक गोल्फ कर सकते हैं: 1 boolean a=1<0,o=L%2>0;.। 2. यदि आपको आवश्यकता नहीं है i, तो इस लूप का उपयोग करें for(i=0;i++<n;):। 3. आप से छुटकारा पा सकते हैं o: j%2<L%2तब j%2>L%2। 4. dफ्लिप के रूप में उपयोग करने में बहुत सारे अक्षर लगते हैं: बस j<(x<0?-x:x)। 5. आपके पास जरूरत से ज्यादा चर हैं। 6. आपको एक पूर्ण कार्यक्रम की आवश्यकता नहीं है: एक लैम्ब्डा या विधि पर्याप्त है। - यदि आप एक गोल्फ जावा उदाहरण चाहते हैं, तो मेरे उत्तर की जांच करें ।

— ओलिवियर ग्रेगोइरे

3

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

f s|l<-length s=[[last$' ':[s!!i|i>=n,mod(n+i)2<1]|i<-[0..l-1]]|n<-abs<$>[-l..l]]

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

— Laikoni
स्रोत

3

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

s->{for(int l=s.length(),i=-l;++i<l;)System.out.printf("%"+l+"s%n",s.substring(i<0?-i:i).replaceAll("(.).","$1 "));}

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

व्याख्या

s->{                                // Consumer<String> lambda
 for(int l=s.length(),i=-l;++i<l;)  // For each length between l and 1 and back to l, 
  System.out.printf("%"+l+"s%n",    // Print with align to right
    s.substring(i<0?-i:i)           // skip the first |i| characters
     .replaceAll("(.).","$1 ")      // replace every even-positioned character with a space.
   );
}

— ओलिवियर ग्रेजायर
स्रोत

3

सी ++, 135 बाइट्स

ठीक है, यहाँ C ++ के साथ मेरा शॉट है:

auto f=[&](auto f,int y)->void{
  for(int i{};i<n;i++) putchar(y<0?f(f,y+1?i+1:n-1-i),'\n':i<y||i+y&1?' ':s[i]);
}; f(f,-1); f(f,-2);

यह ऑनलाइन (ideone) की कोशिश करो!

— एलेक्जेंड्रा पोल्टाव्स्की
स्रोत

3

हास्केल , 140 137 बाइट्स

(m#n)s=(\(i,x)->' ':(last$"  ":[x:" "|rem i 2==m&&i>n]))=<<zip[0..]s
g s=((++)=<<reverse.tail)$id=<<[[(0#n)s,(1#n)s]|n<-[-1,1..length s]]

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

चैलेंजर 5 को 3 बाइट थेल्स सहेजे गए

मुझे नहीं लगता कि यह इष्टतम है ...

fलाइनों में से एक का उत्पादन ( m= 0 या 1 लाइन संख्या का मॉडुलो है,n है)

g "विषम" और "सम" रेखाओं को आपस में जोड़ता है, और परिणाम को स्वयं के दर्पण में जोड़ता है।

— jferard
स्रोत

आप उपसर्ग फ़ंक्शन के बजाय fएक infix फ़ंक्शन (as (m#n)s=...) के रूप में परिभाषित करके बाइट्स बचा सकते हैं ।

— एगलैंगिंग फ्रूट

2

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

j+_Km++*d;@Qdtj;%2>QdUQtK

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

— मिस्टर एक्सकोडर
स्रोत

2

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

JrLm€2Ṭ;€0a⁸o⁶ṚŒḄG

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

— लीक नन
स्रोत

2

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

(c=Characters@#;l=Length@c;StringRiffle@Table[If[Abs[j-l]<i&&EvenQ[j+i],c[[i]]," "],{j,1,2l+1},{i,1,l}])&

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

— केली लोडर
स्रोत

2

जे, 54 बाइट्स

[:|:|.@i.@#(>@],~' '#~[)"_1[:(,' '&,)/&.>>:@i.@#<@#"0]

इसे ऑनलाइन आज़माएं!(ध्यान दें कि TIO पर आउटपुट में एक नई रेखा और तीन स्थान होते हैं, लेकिन यह फ़ंक्शन कॉल से नहीं होता है - यह संभवतः जे इंटरप्रेटर स्वचालित रूप से करता है)।

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

पिछले संस्करण

55 बाइट्स

<:@+:@#{.[:|:|.@i.@#(],~' '#~[)"_1>:@i.@#(,' '&,)/@#"0]

56 बाइट्स

<:@+:@#{.[:|:|.@i.@#(],~' '#~[)"_1#{.[:(,' '&,)//.[:]\.]

व्याख्या

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

dup   =. >:@i.@# <@#"0 ]
space =. (,' '&,)/&.>
pad   =. |.@i.@# (>@],~' '#~[)"_1 ]
trans =. |:

dup स्ट्रिंग में इसके सूचकांक (प्लस एक) के रूप में प्रत्येक चरित्र को कई बार डुप्लिकेट करता है
space प्रत्येक वर्ण के बीच रिक्त स्थान सम्मिलित करता है
pad सही स्थानों के साथ वर्णों को पैड करता है
trans परिणामी मैट्रिक्स को स्थानांतरित करता है

नमूना कॉल:

   trans pad space dup 'abc'
  c
 b 
a c
 b 
  c

dup

>:@i.@# <@#"0 ]
>:@i.@#         Indices of each character plus one
      #          Length of the string
   i.            Range [0,length)
>:               Add one
        <@#"0 ] Duplicate each character as many times as it index (plus one)
           "0   For each
          #   ]  Copy the character
>:@i.@#           as many times as it index
        <        Box the result

परिणाम J को रोकने के लिए बॉक्स को रिक्त स्थान के साथ पैडिंग से रोका जाता है (क्योंकि वे असमान लंबाई के होते हैं)।

नमूना कॉल:

   dup 'abc'
┌─┬──┬───┐
│a│bb│ccc│
└─┴──┴───┘

अंतरिक्ष

(,' '&,)/&.>
         &.>  For each boxed element
(,' '&,)/      Insert spaces between each

नमूना कॉल:

   space dup 'abc'
┌─┬───┬─────┐
│a│b b│c c c│
└─┴───┴─────┘

तकती

|.@i.@# (>@],~' '#~[)"_1 ]
        (>@],~' '#~[)      Pad the right arg with spaces given by the left arg
|.@i.@#                    Indices in reverse order
   i. #                     Range [0,length)
|.                          Reverse

मूल रूप से, लंबाई के साथ पहला तत्व - 1 रिक्त स्थान, लंबाई के साथ दूसरा - 2, आदि। यह बॉक्सिंग को भी हटा देता है।

नमूना कॉल:

   pad space dup 'abc'
  a  
 b b 
c c c

खिसकाना

यह सिर्फ बिल्ट-इन फ़ंक्शन है |:जो एक मैट्रिक्स का संक्रमण लेता है।

— गोभी
स्रोत

1

मैंने एक समान दृष्टिकोण का उपयोग किया, लेकिन मुक्केबाजी से परहेज किया। 45 बाइट्स |:@(-@i.@-@#|."0 1((,@,.~' '#~#)@$"0~1+i.@#)):। यह निश्चित रूप से आगे गोल्फ हो सकता है। यह हिस्सा -@i.@-@#कुछ कम लटका हुआ फल है, सबसे अधिक संभावना है

— योना

@ जोना मैं जल्दी से यह नहीं बता सकता कि आपका उत्तर कैसे काम करता है, इसलिए मैं इसे पोस्ट करने के लिए आपके पास छोड़ दूंगा यदि आप चाहें, तो मैं अपने उत्तर की व्याख्या शामिल करना चाहूंगा। मुझे लगता है कि मेरे लिए अभी J केवल एक लेखन-भाषा है।

— कोल

जल्दी से सड़ने के लिए सहायक: f=. <some tacit expression>फिर, 5!:2 <'f'एक बॉक्सिंग विज़ुअलाइज़ेशन 5!:4 <'f'देता है और एक ट्री विज़ुअलाइज़ेशन देता है। मेरे मामले में, $"0~1+i.@#पहले कुछ स्ट्रिंग के साथ चलने का प्रयास करें , फिर सब कुछ दाईं ओर चलाएं |."0 1, फिर समझें कि |."0 1और बाईं ओर सब कुछ, अंतिम स्थानान्तरण को बचाएं, बस आवश्यक घुमाव कर रहा है।

— जोनाह

1

ओह, मैं आपसे अपने उत्तर को अपडेट करने की उम्मीद नहीं कर रहा था। यह अधिक था "हे, आपको यह दिलचस्प लग सकता है।" मैं इसे पोस्ट कर सकता था, लेकिन लगा कि उच्च-स्तर के दृष्टिकोण समान थे जो इसके लायक नहीं थे।

— जोनाह

2

बस #यहाँ मदद के जटिल तर्कों को याद किया , 26 बाइट्स|:@((-#)|."_1(1j1##)"0)~#\

— मील

1

जावास्क्रिप्ट (ECMAScript 6), 161 बाइट्स

(s,n=console.log)=>s.split("").map((q,i,a,p)=>n(p=" ".repeat(q=a.length-++i)+a.map((v,j)=>j>=q&&j%2==q%2?a[j]+' ':'').join(''))||p).reverse().map((v,i)=>i&&n(v))

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

— sgtdck
स्रोत

1

पर्ल 5 , 86 + 2 (-F) = 88 बाइट्स

बाइट काउंट कम करने के लिए @ डॉम के सुझावों और मेरे खुद के कुछ ट्वीक्स का इस्तेमाल किया।

for$k(0..$#F){$i=1;$a[$#F+$k]=$a[$#F-$k]=[map$i++<$k|($i+$k)%2?$":$_,@F]}say"@$_"for@a

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

— Xcali
स्रोत

इसके बारे में क्षमा करें, ख़ुशी है कि आपको अपना उत्तर मिल गया है, हालाँकि! जब मेरा नाटक ठीक करने की कोशिश की जा रही थी तब थोड़ा सा नाटक किया था और कुडल को हल करने के लिए नहीं मिला, आपका एक बेहतर तरीका था! यह संभव है -aFकि सभी पत्रों को @Fएक-एक करके बाइट्स के एक जोड़े को छोड़ दिया जाए और थोड़े से ट्वीक ( -F3 के रूप में मायने रखता है क्योंकि इसे बाद में जगह की आवश्यकता होती है): इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

1

-F की गिनती 3 के रूप में क्यों होती है? यह 2 सबसे अधिक नहीं होना चाहिए? क्या यह perl -e'code...'और के बीच का अंतर नहीं है perl -eF 'code...'। -aउपयोग करते समय भी अनावश्यक है -F, ताकि बाइट काटा जा सके।

— Xcali

बिलकुल ऐसा ही है। तो -Fएक तर्क को स्वीकार करता है, लेकिन हम एक को पास नहीं करना चाहते हैं ( -Fहमें नियंत्रित करने की अनुमति देता है कि -aकोई विभाजन नहीं है, कोई तर्क नहीं है, प्रत्येक चार को अपने आप से विभाजित करें) इसलिए यह perl -ae '...'और के बीच का अंतर है perl -aF -e '...'। डिफ़ॉल्ट रूप से -aविभाजित करता है/\s+/ । आशा है कि स्पष्ट करने में मदद करता है!

— डोम हेस्टिंग्स

इसके अलावा, का अच्छा उपयोग $#F! हमेशा उस बारे में भूल जाओ!

— डोम हेस्टिंग्स

0

क्यू / केडीबी +, 55 बाइट्स

समाधान:

-1(+){{1_a,((2*y)#" ",z),a:x#" "}'[(|)c;1+c:(!)(#)x]x};

उदाहरण:

q)-1(+){{1_a,((2*y)#" ",z),a:x#" "}'[(|)c;1+c:(!)(#)x]x}"Hello World";
          d
         l
        r d
       o l
      W r d
       o l
    o W r d
   l   o l
  l o W r d
 e l   o l
H l o W r d
 e l   o l
  l o W r d
   l   o l
    o W r d
       o l
      W r d
       o l
        r d
         l
          d

स्पष्टीकरण:

करने के लिए। ungolfed संस्करण 66 बाइट्स है:

-1 flip{{1_a,((2*y)#" ",z),a:x#" "}'[reverse c;1+c:til count x]x};

बोनस:

उदाहरण (74 बाइट्स) के समान आउटपुट प्राप्त करने के लिए:

q)-1(+){1_'raze{(a,((2*y)#" ",z),a:x#" ";(2*y+x)#" ")}'[(|)c;1+c:(!)(#)x]x}"Hello World";
                    d
                  l
                r   d
              o   l
            W   r   d
              o   l
        o   W   r   d
      l       o   l
    l   o   W   r   d
  e   l       o   l
H   l   o   W   r   d
  e   l       o   l
    l   o   W   r   d
      l       o   l
        o   W   r   d
              o   l
            W   r   d
              o   l
                r   d
                  l
                    d

— streetster
स्रोत

एक तार का विस्फोट

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

05AB1E , 10 8 7 बाइट्स

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

C, 86 78 73 70 वर्ण

व्याख्या

SOGL V0.12 , 13 10 9 बाइट्स

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

गैया , 16 बाइट्स

व्याख्या

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

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

ऑक्टेव, 59 63 58 57 बाइट्स

जावा, 292 बाइट्स (क्षमा करें)

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

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

व्याख्या

सी ++, 135 बाइट्स

हास्केल , 140 137 बाइट्स

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

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

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

जे, 54 बाइट्स

पिछले संस्करण

व्याख्या

dup

अंतरिक्ष

तकती

खिसकाना

जावास्क्रिप्ट (ECMAScript 6), 161 बाइट्स

पर्ल 5 , 86 + 2 (-F) = 88 बाइट्स

क्यू / केडीबी +, 55 बाइट्स