72

इस चुनौती के लिए मेरी मदद करने के लिए @KritiiLithos को धन्यवाद !

वी एक प्रोग्रामिंग भाषा है जो मैंने लिखी थी ताकि मैं कोड-गोल्फ चुनौतियों के लिए विम का उपयोग और विस्तार कर सकूं। बहुत पहली प्रतिबद्धता 3 मार्च 2016 को हुई थी, जिसका अर्थ है कि आज V एक साल का हो गया है! वू हू

वी के अस्तित्व के पहले वर्ष में, चार अलग-अलग योगदानकर्ताओं से 176 कमिट किए गए हैं, 12 अलग-अलग उपयोगकर्ताओं से 140 उत्तर , और कई टूटी हुई डुप्लिकेट ऑपरेटरों को गिनने के लिए । इसमें एक ऑनलाइन दुभाषिया है , जिसे उदारतापूर्वक @ डेनिस द्वारा होस्ट किया गया है, जिसे दिसंबर से लगभग 8,000 बार चलाया जा चुका है ।

चलो वी का जन्मदिन मनाने के लिए एक चुनौती है! चूंकि वी में अधिकांश विशेषताएं स्ट्रिंग हेरफेर और एएससीआई-कला को ध्यान में रखते हुए तैयार की जाती हैं, इसलिए यह स्वाभाविक लगता है कि वी को मनाने की कोई भी चुनौती एससीआई कला के बारे में होनी चाहिए। तो आज के लिए आपकी चुनौती एक शब्द को इनपुट के रूप में लेना है, और उस शब्द को V के आकार में फिर से आकार देना है। उदाहरण के लिए, इनपुट "हैलो" में निम्नलिखित V देना चाहिए:

Hello         olleH
 Hello       olleH
  Hello     olleH
   Hello   olleH
    Hello olleH
     HellolleH
      HellleH
       HeleH
        HeH
         H

यहां कुछ विवरण दिए गए हैं कि आपके वी को कैसा दिखना चाहिए। यदि इनपुट स्ट्रिंग n वर्ण लंबा है, तो V को n*2रेखाएँ लंबी होनी चाहिए । पहली पंक्ति में निम्नलिखित शामिल होना चाहिए:

<input string><(n*2) - 1 spaces><input string reversed>

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

आप यह मान सकते हैं कि इनपुट हमेशा बिना किसी व्हाट्सएप के प्रिंट करने योग्य एएससीआईआई होगा, और आप किसी भी उचित तरीके से इनपुट और आउटपुट ले सकते हैं। यहां कुछ और नमूना इनपुट दिए गए हैं:

Happy:

Happy         yppaH
 Happy       yppaH
  Happy     yppaH
   Happy   yppaH
    Happy yppaH
     HappyppaH
      HapppaH
       HapaH
        HaH
         H

Birthday:

Birthday               yadhtriB
 Birthday             yadhtriB
  Birthday           yadhtriB
   Birthday         yadhtriB
    Birthday       yadhtriB
     Birthday     yadhtriB
      Birthday   yadhtriB
       Birthday yadhtriB
        BirthdayadhtriB
         BirthdadhtriB
          BirthdhtriB
           BirthtriB
            BirtriB
             BiriB
              BiB
               B

V!:

V!   !V
 V! !V
  V!V
   V

~:

~ ~
 ~

बेशक, चूंकि यह कोड-गोल्फ है , मानक खामियों पर रोक लगाई जाती है और आपका लक्ष्य इस कार्य को पूरा करने के लिए सबसे कम संभव कार्यक्रम लिखना है। हैप्पी गोल्फिंग!

इसके लायक होने के लिए, मेरे पास विम उत्तरों के लिए एक नरम स्थान है, इसलिए विम या वी का उपयोग करने के लिए काल्पनिक बोनस अंक, हालांकि कोई भी भाषा स्वीकार्य है। :)

code-golf string ascii-art

— DJMcMayhem
स्रोत

क्या मैं हर न्यूलाइन के बाद एक एकल अशक्त चरित्र (0x00) प्रिंट कर सकता हूं?

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

@wheatwizard हम्म। यह थोड़ा अजीब है, लेकिन मुझे लगता है कि यह तब तक ठीक है जब तक आउटपुट नेत्रहीन समान है।

— DJMcMayhem

21

5 वां जन्मदिन कुछ और होगा! (रोमन अंकों में)

— अल्बर्ट रेनशॉ

5

वी भाषा द्वारा वी भाषा के लिए शुभकामनाएँ :-)

— वी

44

MATL , 21 14 बाइट्स

MATL ने V को जन्मदिन की शुभकामनाएं दीं!

tnEXyY+c3MZvZ)

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

व्याख्या

इनपुट पर विचार करें

'Hello'

लंबाई की n=5। कोड आकार के पहचान मैट्रिक्स के साथ इस स्ट्रिंग के 2 डी कन्वेंशन की गणना करता है 2*n,

[1 0 0 0 0 0 0 0 0 0;
 0 1 0 0 0 0 0 0 0 0;
 0 0 1 0 0 0 0 0 0 0;
 0 0 0 1 0 0 0 0 0 0;
 0 0 0 0 1 0 0 0 0 0;
 0 0 0 0 0 1 0 0 0 0;
 0 0 0 0 0 0 1 0 0 0;
 0 0 0 0 0 0 0 1 0 0;
 0 0 0 0 0 0 0 0 1 0;
 0 0 0 0 0 0 0 0 0 1]

कनवल्शन का परिणाम, चार में परिवर्तित हो गया और चार के साथ अंतरिक्ष के रूप में दिखाया गया है

['Hello         ';
 ' Hello        ';
 '  Hello       ';
 '   Hello      ';
 '    Hello     ';
 '     Hello    ';
 '      Hello   ';
 '       Hello  ';
 '        Hello ';
 '         Hello']

तब [1, 2, ..., 2*n-1, 2*n, 2*n-1, ..., 2, 1]इस चार मैट्रिक्स से कॉलम चुने जाते हैं, जिससे वांछित परिणाम प्राप्त होते हैं:

['Hello         olleH';
 ' Hello       olleH ';
 '  Hello     olleH  ';
 '   Hello   olleH   ';
 '    Hello olleH    ';
 '     HellolleH     ';
 '      HellleH      ';
 '       HeleH       ';
 '        HeH        ';
 '         H         ']

टिप्पणी कोड

t      % Implicitly input string. Duplicate
nE     % Length, say n. Multiply by 2
Xy     % Identity matrix of that size
Y+     % 2D convolution. This converts chars to ASCII codes
c      % Convert to char
3M     % Push 2*n, again
Zv     % Push symmetric range [1, 2, ..., 2*n, 2*n-1, ..., 1]
Z)     % Apply as column indices. This reflects the first 2*n columns
       % symmetrically, and removes the rest. Implicitly display

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

बहुत दिलचस्प दृष्टिकोण! +1

— शीशमारा

3

@seshoumara धन्यवाद! जैसा कि फ्लर कहते हैं, दृढ़ संकल्प सफलता की कुंजी है :-)

— लुइस मेंडो

38

वी , 24, 23 , 20 बाइट्स

3Ù2Ò Íî
Xæ$òâÙHãêxx>

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

अभी बहुत कम है कि वी में एक 'रिवर्स' ऑपरेटर है ।

अन्य गोल्फ भाषाओं की तुलना में प्रभावशाली नहीं है, जिन्होंने उत्तर दिया है, लेकिन यह किया जाना था। Hexdump:

00000000: 33d9 32d2 20cd ee0a 58e6 24f2 e2d9 48e3  3.2. ...X.$...H.
00000010: ea78 783e                                .xx>

स्पष्टीकरण:

3Ù                  " Make three extra copies of this current line
  2Ò                " Replace each character on this line and the next line with spaces
     Íî             " Join all lines together
X                   " Delete one space
 æ$                 " Reverse the word under the cursor

इस बिंदु पर, बफर इस तरह दिखता है:

Happy         yppaH

नहीं, हम पुनरावर्ती रूप से त्रिभुज का निर्माण करेंगे।

ò                   " Recursively:
 â                  "   Break if there is only one non-whitespace character on this line
  Ù                 "   Make a copy of this line
   H                "   Move to the first line
    ã               "   Move to the center of this line
     ê              "   Move to this column on the last line
      xx            "   Delete two characters
        >           "   Indent this line

यहाँ है जहाँ मुझे वी। लोट्स की मेरी पसंदीदा विशेषताओं में से एक को दिखाने के लिए मिलता है, इसके लिए एक तर्क की आवश्यकता होती है। उदाहरण के लिए, >कमांड तर्क के आधार पर एक चर संख्या का संकेत देगा:

>>    " Indent this line (this command is actually a synonym for '>_')
>j    " Indent this line and the line below
>k    " Indent this line and the line above
6>>   " Indent 6 lines
>}    " Indent to the end of this paragraph
>G    " Indent to the last line
...   " Many many many more

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

òâÙHãêxx>>ò

दूसरा òअंतर्निहित रूप से भरा हुआ है। अच्छी बात यह है कि स्पष्ट रूप से समाप्त आदेश कई परतों को गहराई से लागू करते हैं, इसलिए भले ही हमने केवल लिखा है >, वी निहित रूप _से इसके लिए तर्क देगा, और यह वर्तमान लाइन को इंडेंट करेगा।

— DJMcMayhem
स्रोत

मैं इस पर काम कर रहा था, लेकिन मुझे लगता है कि यह आपके लिए जवाब देने के लिए अधिक उपयुक्त है!

— nmjcman101

29

ब्रेनफक , 152 बाइट्स

यह एक ऐसा महत्वपूर्ण अवसर है, मैंने राजभाषा 'बीएफ दुभाषिया' को क्रैक करने और इसे एक स्पिन देने का फैसला किया।

++++++++++[->+>+++<<]>>++>>+>>>,[[<]<<+>>>[>],]<[<]<<-[->+>>[>]>++++[-<++++++++>]<[<]<<]>[->++<]>[-<+>]<[<[-<+<.>>]<[->+<]>+>->>[.>]<[-]<[.<]<<<<<.>>>>]

टिप्पणियों के साथ

++++++++++
[->+>+++<<] Insert 0 into the first buffer (Which we don't care about) 10 into the second and 30 into the thrd
>>++    Raise the third buffer to 32 making us our space
>   This buffer is reserved for the Insertable spaces counter
>
+>>>    Raise our incrementer This will be used to fill the other half of the string with spaces
,[  Read a byte
    [<]<<   Move to the back of the string buffer which is our incrementer
    +       increment it
    >>>[>]      And move to the next space of the string
    ,       And then read a new byte
]
<[<]<<-     Decrement the incrementer and begin to add spaces
[
    -       Decrement the incrementer
    >+      Raise the incrementer in the padding
    >>[>]   Move to a new part of the string buffer
    >++++[-<++++++++>]< Write a space
    [<]<<   Move all the way back to the string counter
]
BEGIN WRITING!!
>
[->++<]>[-<+>]<Double the incrementer
[
    <[  Move to the space counter
        -<+<.>> Decrement the space counter increment the temporary one to the left of it then print the space we stored to the left of that then return
    ]<[->+<]>+> Move the temporary space counter back
    -   Decrement the incrementer
    >>[.>]  Print every character from left to right
    <[-]    Snip the end off this
    <[.<]   Print every character from right to left
    <   Move back ot the incrementer
    <<<<.>>>> Print a newline aswell
]

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

— Ataco
स्रोत

23

> <> , 221 बाइट्स

मैं बिताया तरह से इस पर बहुत अधिक समय। जन्मदिन मुबारक हो, वी!

l:2*01           p84*/v
 !@:$-1         /!?:$<
  1.v/ ^       v\~~>a
   vv\}o<     >ao  /
    1\/84/   :}o:$-
     \\!?<: l;!?\v
      p10-1:g10r\
       >  :>?\vv
        v:$-1/~
         </r+*
          </~
           l

आप इसे ऑनलाइन आज़मा सकते हैं , लेकिन इस दुभाषिए को पाने और --playझंडे का उपयोग करके इसे चलाने में बहुत मज़ा आता है

python3 fish.py v.fish -s "ppcg" --tick 0.05 --play

जिसके परिणामस्वरूप नीचे एनीमेशन है।

उदाहरण

(यह दो मिनट से थोड़ा कम समय लगता है)

व्याख्या

क्योंकि इस उत्तर का दिलचस्प हिस्सा इसे Vआकार में लपेट रहा है , यहाँ एक स्पष्टीकरण है जो इसके अनुरूप है। हम संदर्भ के लिए निम्नलिखित पंक्तिबद्ध संस्करण का उपयोग करते हैं।

1. l:2*01           p84*/v
2.  !@:$-1         /!?:$<
3.   1.v/ ^       v\~~>a
4.    vv\}o<     >ao  /
5.     1\/84/   :}o:$-
6.      \\!?<: l;!?\v
7.       p10-1:g10r\
8.        >  :>?\vv
9.         v:$-1/~
10.         </r+*
11.          </~
12.           l

कभी-कभी तीर (→ ← ↓) का उपयोग उस दिशा को इंगित करने के लिए किया जाता है जिसमें एक स्निपेट पहुंच जाता है।

initialisation
```
   1.→l:2*01           p84*/v
   2.  !@:$-1   X     /!?:$<
   3.   1.            \~~>a
```
पहली पंक्ति 2n को [0,1] पर धकेल देगी , स्टैक पर n छोड़ दें और एक स्थान को जोड़ दें । अगला, हम ऊपर जाते हैं और दाईं ओर दूसरी पंक्ति के चारों ओर लपेटते हैं, जहां हम बाएं जाना शुरू करेंगे। N + 1 रिक्त स्थान को जोड़ने के लिए एक लूप है । यह निम्नानुसार काम करता है।
```
                Initial:                 "ppcg4 "
!@:$-1 /!?:$<
           $     Swap.                   "ppcg 4"
          :      Duplicate.              "ppcg 44"
         ?       If more spaces to add:
    -1            Subtract 1.            "ppcg 3"
   $              Swap.                  "ppcg3 "
  :               Duplicate.             "ppcg3  "
 @                Rotate top 3.          "ppcg 3 "
!                 Jump over stored value
                         and wrap around.
                Else:
        /         Go to next part.
```
इसके समाप्त होने के बाद, यह नीचे की ओर झुकता है। 3. शीर्ष दो स्टैक तत्व (0 और एक स्पेस) को हटा दिया जाता है ( ~~) और हम सही Xस्थान पर चलते हुए [10,1] ( a1.) पर जाते हैं। हम में टकराते हैं /, लाइन 7 के चारों ओर लपेटते हैं और मुख्य प्रोग्राम लूप शुरू करते हैं।
मुख्य लूप ( 2n बार करते हैं)
```
 6.              ;!?\
 7.       p10-1:g10r\   ←
```
यह लूप कंडीशन है। सबसे पहले, मुद्रण के लिए स्टैक को उलट दिया जाता है। फिर हमें काउंटर [1,0] ( 01g) से मिलता है और एक डीग्रेडेड वर्जन ( :1-01p) स्टोर करता है । चारों ओर लपेटकर और ऊपर और दाईं ओर, हम कार्यक्रम को समाप्त करने के लिए सशर्त मुठभेड़ करते हैं। यदि हम समाप्त नहीं करते हैं, तो हम पहले प्रिंटिंग लूप में कूदते हैं।
- पहले मुद्रण लूप (बाएं आधा)
```
5.    1\   /   :}o:$-
6.     \\!?<: l         ←
```
  हम स्टैक के शीर्ष पर लंबाई के साथ शुरू करते हैं और निम्नलिखित कोड निष्पादित करते हैं जब तक कि शीर्ष तत्व 0 नहीं है।
```
1-$:o}

1-        Subtract 1.    "ppcg3"
  $       Swap.          "ppc3g"
   :      Duplicate.     "ppc3gg"
    o     Output.        "ppc3g"
     }    Rotate right.  "gppc3"
```
  यह ढेर को छोड़े बिना ही प्रिंट कर देगा। यदि लूप समाप्त हो जाता है, तो हम अगले मुद्रण लूप की तैयारी के लिए, लाइन 5 पर दाईं ओर कूदते हैं।
- सही आधे की तैयारी
```
5.  →    /84/   
6.       \     
7.            :    
8.            >
9.         v:$-1/~
10.         </r+*
11.          </~
12.           l
```
  यह फिट करने के लिए सबसे कठिन भागों में से एक था। नीचे एक संस्करण है जो सभी दिशाओं को छीनता है जो यह बताता है कि क्या होता है।
```
             Initial stack:   "    gcpp0"
84*+r~
84*          Push 32 == " ".  "    gcpp0 "
   +         Add 32 and 0.    "    gcpp "
    r        Reverse.         " gcpp    "
     ~       Remove top.      " gcpp   "
```
  फिर हम मुद्रित होने वाली लंबाई को धक्का देते हैं और दूसरे प्रिंटिंग लूप को शुरू करते हैं (लूप का प्रारंभिक डुप्लिकेट नहीं भाग के साथ)।
- दूसरा प्रिंटिंग लूप (दायां आधा)
```
3.     / ^ 
4.     \}o<
5.    
6.           ↓   
7.           
8.       >  :>?\vv
9.        v:$-1/~ 
```
  जिस कोड को निष्पादित किया जा रहा है वह पूरी तरह से पहले प्रिंटिंग लूप के समान है, जिसमें o}थोड़ा आगे रखा गया है क्योंकि उपलब्ध स्थान थे। खत्म करने से पहले, हमारे पास मुख्य लूप इनवेरिएंट को फिर से सत्यापित करने से पहले कुछ चीजें होनी बाकी हैं। ~9 लाइन निष्पादित होने के बाद हम लंबवत रूप से लपेटते हैं, कोड के निम्नलिखित टुकड़े पर समाप्त होता है।
```
                ↓
2.          X     / 
3.  1.v/             >a
4.              >ao  /
```
  सबसे पहले aoएक नई लाइन प्रिंट करेंगे। फिर हम उछलते हैं और आरंभीकरण के बाद उसी स्थान पर पहुंचते हैं, अर्थात् कूदते हुए X।

— PidgeyUsedGust
स्रोत

आपको संभवत: गोल्फ संस्करण को मुख्य संस्करण बनाना चाहिए

— विनाशकारी नींबू

1

@DestructibleWatermelon पोस्ट V संस्करण के बारे में अधिक है, हालांकि, विशिष्ट आकार में केवल उपलब्ध बाइट्स की सीमित संख्या के साथ सब कुछ ढालना बहुत कठिन था । इसलिए स्पष्टीकरण वी संस्करण के लिए अनुसरण करेगा, बजाय सादे एक के। मैं बाद में वास्तव में एक गोल्फ बना सकता हूं।

— पेइजियुइटगस्ट

यह सोना सिर्फ सोना है

— क्रिस्टोफर

मैं सराहना करता हूं कि यह जवाब एक ऐसी भाषा में है, जिसका नाम विशेष रूप से घुमाया हुआ वी के है।

— सेल्यमे

19

ब्रेन-फ्लैक , 486 + 1 = 489 बाइट्स

ब्रेन-फ्लैक से जन्मदिन की शुभकामनाएँ!

इसके अलावा एक धन्यवाद 0 से ' जो इस उत्तर में इस्तेमाल किए गए कुछ कोड प्रदान करता है

+1 उस -cध्वज के कारण है जो ASCII के लिए आवश्यक है

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

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

यह बिना किसी संदेह के सबसे मुश्किल काम है जो मैंने ब्रेन-फ्लैक में किया है।

ब्रेन-फ्लैक डुप्लिकेटिंग और रिवर्सलिंग स्ट्रिंग्स में बहुत ही भयानक है और इस चुनौती में डुप्लिकेटिंग और स्ट्रिंग्स को उलटने के अलावा और कुछ नहीं है।

मैं केवल एक घंटे की कड़ी मेहनत के तहत इस लगभग काम कर रहे स्निपेट को प्राप्त करने में कामयाब रहा , लेकिन पिछले कुछ स्थानों को जोड़कर देखा जाए तो मैं ब्रेन-फ्लैक में अब तक की सबसे कठिन चीजों में से एक हूं।

व्याख्या

मूल विचार यह है कि हम पहले V के शीर्ष को बनाएंगे और प्रत्येक पुनरावृत्ति को दो वर्णों को बीच से हटाकर शुरुआत में स्थान जोड़ेंगे।

व्यवहार में यह काफी कठिन हो जाता है।

मौजूदा एल्गोरिदम कॉपी और रिवर्स के लिए मौजूद हैं, इसलिए मैंने ऑफ़स्टैक पर कोड की एक उलट कॉपी बनाने के लिए उनमें से एक का उपयोग किया। एक बार जब मैंने किया है कि मैं 2n-1मूल ढेर के ऊपर रिक्त स्थान डाल देता हूं और एक सैंडविच बनाने के लिए ऑफस्टैक को बैकस्टैक पर स्थानांतरित करता हूं।

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

यह कठिन है।

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

तो हम इसे कैसे ठीक करते हैं? संक्षेप में हम वास्तव में नहीं हैं; हम अभी के लिए रिक्त स्थान को अनदेखा करते हैं और बाद में उन्हें पैच करते हैं, हम शून्य को कोड में जोड़कर चिह्नित करेंगे जहां रिक्त स्थान जाने का इरादा है लेकिन इसके अलावा हम वास्तव में कुछ भी नहीं करेंगे।

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

अब हमारे पास V का थोक निर्माण है। हालाँकि हमें उचित स्थानों की कमी है और हमारा V वर्तमान में थोड़ा (पढ़ा: पूरी तरह से) उल्टा है।

इसलिए हम इसे फ्लिप करते हैं। इसे दूसरे स्टैक पर पलटने के लिए हमें एक-एक करके प्रत्येक तत्व को स्थानांतरित करना होगा। जैसा कि हम चल तत्वों हम शून्य के लिए जाँच कर रहे हैं। यदि हम एक मुठभेड़ करते हैं तो हमें उन स्थानों को वापस रखना होगा जहां वे हैं। हम शून्य को चकते हैं और रिक्त स्थान के एक समूह में जोड़ते हैं। हम कैसे जानते हैं कि कितने हैं? हम नज़र रखते हैं; डुप्लिकेट या उलट के विपरीत एक स्टैक को फ़्लिप करना एक बहुत ही अन-इंटेंसिव कार्य है इसलिए हमारे पास अतिरिक्त रिक्त स्थान को जोड़ने के लिए अतिरिक्त काउंटर को स्टोर करने और एक्सेस करने की मेमोरी है। हर बार जब हम कुछ रिक्त स्थान जोड़ते हैं, तो हम काउंटर को एक-एक करके घटाते हैं। काउंटर को अंतिम न्यूलाइन (वी के शीर्ष) पर शून्य हिट करना चाहिए और इस प्रकार हम प्रिंट करने के लिए तैयार हैं।

अंत में हम कुछ चीजों को इधर-उधर लटका कर साफ करते हैं और अंतर्निहित आउटपुट के लिए कार्यक्रम को समाप्त करते हैं।

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

बहुत प्रभावशाली है कि आप इसे काम करने में कामयाब रहे! क्या आपको लगता है कि आप बाइट्स को उलट कर और -rझंडे को जोड़कर बचा सकते हैं ?

— DJMcMayhem

@DJMcMayhem मुझे ऐसा नहीं लगता। रिवर्सल प्रक्रिया और रिक्त स्थान का सम्मिलन एक ही समय में होता है, इसलिए यदि मैंने -rध्वज जोड़ा तो मुझे वास्तव में इसे दूसरी बार रिवर्स करने की आवश्यकता होगी। यह देर से हो रहा है जहां मैं हूं लेकिन मुझे लगता है कि मैं कल इसे काफी कम करने की कोशिश करूंगा। यदि मैं रिक्त स्थान की समस्या को ठीक कर सकता हूं तो मैं निश्चित रूप से -rध्वज का उपयोग करूंगा ।

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

16

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

⁶ṁ⁸;;\Uz⁶ŒBY

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

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

⁶ṁ⁸;;\Uz⁶ŒBY  Main link. Argument: s (string)

⁶ṁ            Mold ' ' like s, creating a string of len(s) spaces.
  ⁸;          Prepend s to the spaces.
    ;\        Cumulative concatenation, generating all prefixes.
      U       Upend; reverse each prefix.
       z⁶     Zip/transpose, filling empty spots with spaces.
         ŒB   Bounce; map each string t to t[:-1]+t[::-1].
           Y  Join, separating by linefeeds.

— डेनिस
स्रोत

यह 12 वर्ण है, लेकिन क्या कोई एन्कोडिंग है जहां यह सिर्फ 12 बाइट्स के रूप में सामने आएगा?

— कास्परड

1

हाँ, जेली इसे अपने कस्टम कोड पेज का उपयोग करता है ।

— डेनिस

16

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

s=input();s+=' '*len(s)
for _ in s:s=' '+s[print(s+s[-2::-1]):-1]

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

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

s=input();s+=' '*len(s)
for _ in s:print s+s[-2::-1];s=' '+s[:-1]

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

— डेनिस
स्रोत

16

जावास्क्रिप्ट (ईएस 6), 108 106 98 94 बाइट्स

f=
s=>s.repeat((j=l=s.length*4)*2).replace(/./g,_=>--j?s[j+j<l?j-i:l-i-j]||` `:(j=l,++i,`
`),i=1)

<input oninput=o.textContent=f(this.value)><pre id=o>

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

— नील
स्रोत

क्या आप इसे समझाते हुए कोई पोस्ट बना पाएंगे? मैं प्रतिस्थापन से थोड़ा भ्रमित हूं, और नियमित अभिव्यक्ति।

— जैकब फारसी

@JacobPersi वे एक लाल हेरिंग हैं। सभी मैं जरूरत आकार की एक उत्पादन क्षेत्र है n*2द्वारा n*4(प्रत्येक पंक्ति के अंत में नई-पंक्तियों सहित)। फिर मैं उस चरित्र की गणना करता हूं जो प्रत्येक सेल में दिखाई देना चाहिए।

— नील

अच्छा! आप के बीच न्यू लाइन को हटाने के द्वारा एक बाइट बंद दाढ़ी कर सकते हैं f=और s=>।

— युम्मिस्तफा

@yummypasta f=स्निपेट का केवल एक हिस्सा है, उत्तर नहीं। जैसे, यह बाइट की गिनती में शामिल नहीं है।

— नील

11

रेटिना , 51 47 बाइट्स

साथी स्ट्रिंग-प्रोसेसिंग भाषा से जन्मदिन की शुभकामनाएँ!

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

$
$.`$* 
$
¶$`
O$^r`.\G

;{*`.¶

(\S.*).¶.
 $1¶

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

व्याख्या

$
$.`$*

यह स्ट्रिंग के अंत से मेल खाता है , और इसके साथ कई बार एक स्थान को दोहराते हुए, यह nरिक्त स्थान को जोड़ता है (जहां nस्ट्रिंग की लंबाई है) ।$.`$*

$
¶$`

हम स्ट्रिंग के अंत को फिर से मिलान करके और स्ट्रिंग को खुद के साथ जोड़कर पूरे स्ट्रिंग (एक लाइनफ़ीड द्वारा अलग) की नकल करते हैं $`।

O$^r`.\G

यह दाएं-से-बाएं ( r) से मेल खाते हुए दूसरी पंक्ति को उलट देता है , फिर एक समय ( .) पर एक चरित्र का मिलान करता है, लेकिन यह सुनिश्चित करता है कि वे सभी आसन्न ( \G) हैं। इस तरह, मैच लाइनफ़ीड से आगे नहीं बढ़ सकते। यह तब सॉर्ट-स्टेज में उपयोग किया जाता है। सॉर्ट-बाय मोड ( $) का उपयोग करके लेकिन प्रत्येक मैच को एक खाली स्ट्रिंग के साथ बदलने पर, कोई वास्तविक छँटाई नहीं की जाती है। लेकिन ^विकल्प के कारण , मैचों को दूसरी दूसरी पंक्ति में उलट दिया जाता है।

;{*`.¶

यह चरण आउटपुट के लिए है और बाकी प्रोग्राम को भी प्रभावित करता है। {शेष चरणों को एक लूप में लपेटता है जो तब तक दोहराया जाता है जब तक कि वे चरण स्ट्रिंग को बदलने में विफल नहीं हो जाते हैं (जो तब होगा क्योंकि अंतिम चरण किसी भी अधिक मेल नहीं खाएगा)। ;कार्यक्रम के अंत में अक्षम उत्पादन। *बारी-बारी से एक सूखी रन जिसका अर्थ है कि मंच संसाधित किया जाता है और परिणाम मुद्रित किया जाता है, लेकिन बाद में पिछले स्ट्रिंग पुनर्स्थापित किया जाता है में इस स्तर।

मंच ही एक लाइनफीड और पूर्ववर्ती चरित्र को हटा देता है। जो हमें वांछित आउटपुट की एक पंक्ति देता है (पहली पंक्ति से शुरू)।

(\S.*).¶.
 $1¶

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

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

यह कैसे काम करता है, इसका स्पष्टीकरण पसंद करेंगे। मुझे पता है कि sed का सिंटैक्स कम कॉम्पैक्ट है, लेकिन मेरा ड्राफ्ट दो बार लंबा है। स्ट्रिंग को पीछे करना और पहली आउटपुट लाइन को एक साथ रखना सबसे अधिक है।

— शेषमारा

@ शेशमौरा ज़रूर, वहाँ तुम जाओ।

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

धन्यवाद। अब मुझे पता है कि एक दोहरी लंबाई वाली सीड स्क्रिप्ट खराब नहीं है :)) अतिरिक्त s///वर्णों के कारण , जो लंबी स्ट्रिंग स्ट्रिंग उलट और अन्य परिचालनों में रेटिना की बारीकियों की कमी है। अच्छा पढ़ा। +1

— शीशमारा

9

05AB1E , 12 बाइट्स

Dgð×J.p€ûR.c

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

व्याख्या

D             # duplicate input
 g            # length of copy
  ð×J         # append that many spaces to input
     .p       # get a list of all prefixes
       €û     # turn each into a palindrome
         R    # reverse the list
          .c  # pad each line until centered

या उसी बाइट के लिए दूसरी दिशा से गिनती करें।

Âsgú.sí€ûR.c

व्याख्या

Â             # push a reversed copy of input
 s            # swap the input to the top of the stack
  g           # get its length
   ú          # prepend that many spaces
    .s        # get a list of all suffixes
      í       # reverse each
       €û     # turn each into a palindrome
         R    # reverse the list
          .c  # pad each line until centered

— Emigna
स्रोत

2

यदि आप टिप्पणियों को

— बढ़ा

9

जाप, २२ २० १६ १४ + २ बाइट्स

जाप वी को गोल्फ के कई और सफल वर्ष की शुभकामनाएं देता है!

²¬£²îU²ç iYU)ê

-Rध्वज की आवश्यकता है । इसे ऑनलाइन टेस्ट करें!

व्याख्या

यह कुछ दिनों पहले मेरे द्वारा जोड़े गए कार्यों çऔर îकार्यों का उपयोग करता है :

²¬£²îU²ç iYU)ê    Implicit: U = input string
²                 Double the input string.
 ¬                Split into chars.
  £               Map each char X and index Y by this function:
     U²             Take the input doubled.
       ç            Fill this with spaces.
         iYU        Insert the input at index Y.
    î       )       Mask: repeat that string until it reaches the length of
   ²                the input doubled.
                    This grabs the first U.length * 2 chars of the string.
             ê      Bounce the result ("abc" -> "abcba").
                  Implicit: output result of last expression, joined by newlines (-R flag)

डेनिस की तकनीक अब बाइट है:

U+Uç)å+ mw y mê

— ETHproductions
स्रोत

5

GNU सेड , 110 100 + 1 (आर झंडा) = 101 बाइट्स

संपादित करें: 9 बाइट्स रिले के लिए धन्यवाद

एक और स्ट्रिंग परिवर्तन भाषा के रूप में, एसईडी इच्छाओं वी सबसे अच्छा!

h;G
:;s:\n.: \n:;t
h;:r;s:(.)(\n.*):\2\1:;tr
H;x
s:\n\n ::
:V
h;s:\n::p;g
s:^: :;s:.\n.:\n:
/\n$/!tV

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

स्पष्टीकरण: इनपुट मानते हुए अंतिम परीक्षण मामला ('V!') है। मैं स्पष्टता के लिए प्रत्येक चरण में पैटर्न स्पेस दिखाऊंगा, 'एस' के साथ रिक्त स्थान की जगह।

h;G                       # duplicate input to 2nd line: V!\nV!
:;s:\n.: \n:;t            # shift each char from 2nd line to 1st, as space: V!SS\n
h;:r;s:(.)(\n.*):\2\1:;tr # save pattern space, then loop to reverse it: \nSS!V
H;x                       # append reversed pattern to the one saved V!SS\n\n\nSS!V
s:\n\n ::                 # convert to format, use \n as side delimiter: V!SS\nS!V
:V                        # start loop 'V', that generates the remaining output
h;s:\n::p;g               # temporarily remove the side delimiter and print pattern
s:^: :;s:.\n.:\n:         # prepend space, delete char around both sides: SV!S\n!V
/\n$/!tV                  # repeat, till no char is left on the right side
                          # implicit printing of pattern left (last output line)

— seshoumara
स्रोत

@ रिले जवाब अपडेट हुआ, धन्यवाद!

— शीशमारा

4

अजगर, 110 बाइट्स

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

मुझे यकीन है कि यह इष्टतम नहीं है, लेकिन यह बहुत कम से कम पायथन है:

def f(s):n=len(s)*2-1;return''.join(i*' '+s[:n+1-i]+(n-2*i)*' '+s[n-i-1::-1]+'\n'for i in range(n))+n*' '+s[0]

— Hactar
स्रोत

4

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

जोल्फ ने बधाई देते हुए वी को जन्मदिन की शुभकामनाएं दीं!

RΜwzΒώlid+γ_pq_ l+*␅Hi0ΒΒ␅ L_γ1S

यहाँ कोशिश करो! ␅0x05 होना चाहिए।

व्याख्या

RΜzΒώlid+γ_pq_ l+*␅Hi0ΒΒ␅ L_γ1S  i = input
     li                                  i.length
    ώ                                2 * 
   Β                             Β =
  z                              range(1, Β + 1)
 Μ     d                         map with: (S = index, from 0)
                +                 add:
                 *␅H               S spaces
                    i              and the input
               l                  slice (^) from
                     0Β            0 to Β
           pq_         Β␅         pad (^) with spaces to the right
         γ_                       γ = reverse (^)
        +                 L_γ1    γ + behead(γ)
R                             S  join with newlines

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

4

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

जन्मदिन की बधाई वी, आपके साथी निराशाजनक-से-इस-चुनौती ASCII- कला भाषा के लिए!

ＳσＦ…·¹Ｌσ«Ｆι§σκＭι←↖»Ｆσ«Ｐσ↖»‖Ｏ→

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

व्याख्या

हमारी रणनीति: वी के बाएं आधे हिस्से को प्रिंट करें, नीचे से शुरू होकर ऊपरी बाईं ओर जाएं; फिर इसे प्रतिबिंबित करें।

Ｓσ                                    Input σ as string
                                       The bottom len(σ) half-rows:
   Ｆ…·¹Ｌσ«           »               For ι in inclusive range from 1 to length(σ):
            Ｆι                          For κ in range(ι):
               §σκ                         Print character of σ at index κ
                  Ｍι←                   Move cursor ι spaces leftward
                      ↖                  Move cursor one space up and left
                                       The top len(σ) half-rows:
                        Ｆσ«    »      For each character ι in σ:
                            Ｐσ          Print σ without moving the cursor
                               ↖         Move cursor one space up and left
                                 ‖Ｏ→  Reflect the whole thing rightward, with overlap

(यदि केवल चारकोल में स्ट्रिंग स्लाइसिंग था ... अफसोस, ऐसा प्रतीत होता है कि अभी तक लागू नहीं किया गया है।)

— DLosc
स्रोत

हालांकि चारकोल में स्ट्रिंग स्लाइसिंग नहीं थी, लेकिन यह था CycleChop, जिसका उपयोग स्ट्रिंग के सिर को निकालने के लिए किया जा सकता है, इस प्रकार 4 बाइट्स की बचत होती है। हालांकि, एक बेहतर तरीका है जो 9 बाइट्स बचाता है। कुछ और बचत जो मुझे लगता है कि उस समय भी काम की थी: Reflectएक सही बाइट को डिफॉल्ट करता है, एक और बाइट की बचत करता है, और एक चर को पहले इनपुट के लिए पूर्वनिर्धारित किया जाता है, जिससे दो बाइट्स बचते हैं।

— नील

4

पिप , 32 25 बाइट्स

a.:sX#aL#a{OaDQaPRVaaPUs}

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

व्याख्या

                           a is 1st cmdline arg, s is space (implicit)
     #a                    Len(a)
   sX                      Space, string-multiplied by the above
a.:                        Concatenate that to the end of a
       L#a{             }  Loop len(a) times (but NB, a is now twice as long as it was):
           Oa                Output a (no trailing newline)
             DQa             Dequeue one character from the end of a
                PRVa         Print reverse(a) (with trailing newline)
                    aPUs     Push one space to the front of a

— DLosc
स्रोत

4

आर स्ट्रिंग पैकेज के साथ, 225 बाइट्स

library(stringi)
f=function(){
s=scan(,'',1,sep="\n")
m=2*nchar(s)
l=stri_pad(sapply(1:m-1,function(x)substr(paste(paste(rep(" ",x),collapse=""),s),1,m)),m,"right")
r=substr(stri_reverse(l),2,m)
message(paste0(l,r,"\n"))}
f()

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

स्पष्टीकरण:

मूल विचार बाईं ओर रिक्त स्थान जोड़ना है, फिर इसे दाईं लंबाई में काटें। उसके बाद, इसे अपने उल्टे संस्करण के साथ दाईं ओर चिपकाएं। यहां फ़ंक्शन का एक लंबा, मानव-पठनीय संस्करण है:

library(stringi)
make_V <- function(){                  # declaring the function
  string <- scan(, '', n=1, sep="\n")  # reading input
  max_length <- 2*nchar(string)        # number of chars in each half row

  # creating the left side of the V

  left <- stri_pad(                    
            sapply(1:max_length-1,     # for each row
                   function(x){     
                    substr(            
                      paste0(
                        paste0(rep(" ", x),
                               collapse=""), string), # add spaces to left side
                           1,
                           max_length) # cut the unneeded end
                    }),
            width=max_length,
            side="right")              # add spaces to the right side

  # creating the right side of the V

  right <- substr(stri_reverse(left), 2, max_length)

  # print it without any symbols before the strings 
  message(paste0(left, right, "\n"))
}

# run the function
make_V()

— atajti
स्रोत

साइट पर आपका स्वागत है! :)

— DJMcMayhem

4

रूबी, 92 89 85 बाइट्स

s=gets.chomp
s<<" "*n=s.size*2
n.times{s=s[0..(n-1)]
puts s+s.reverse[1..-1]
s=" "+s}

मेरी प्रक्रिया पहली पंक्ति को उलटने के बाद प्रत्येक पंक्ति के दाहिने आधे हिस्से से पहले चरित्र को हटाने की थी। ऐशे ही:

Hello     |    olleH
 Hello    |   olleH 
  Hello   |  olleH  
   Hello  | olleH   
    Hello |olleH    
     Hello|lleH     
      Hell|leH      
       Hel|eH       
        He|H        
         H|

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

— user3334690
स्रोत

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

— डीजेएमकेम

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

— user3334690

1

मुझे लगता है कि [रूबी] सिर्फ रूबी है, अधिक-या-कम प्रसिद्ध प्रोग्राम भाषा?

— R

आप इसे एक मेमना बनाकर 8 बाइट्स बचा सकते हैं ।

— जॉर्डन

4

बैच, 186 185 बाइट्स

@set e=@set 
%e%/ps=
%e%t=%s%
%e%r=
:l
%e%s=%s% 
%e%r= %r%%t:~-1%
%e%t=%t:~,-1%
@if not "%t%"=="" goto l
:g
%e%r=%r:~1%
@echo %s%%r%
%e%s= %s:~,-1%
@if not "%r%"=="" goto g

लाइनों 1 और 6 में एक अनुगामी स्थान है। संपादित करें: @ ConorOBrien के लिए 1 बाइट का धन्यवाद सहेजा गया।

— नील
स्रोत

1

यहां एक बाइट बचाने के लिए एक जटिल तरीका है । ( आवश्यक के लिए डालने @set और हटाने के लिए एक उपनाम बनाएं @echo off,@

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

@ ConorO'Brien धन्यवाद, मैंने कभी अनुमान नहीं लगाया होगा कि 8 sets ने मुझे इस लायक बनाने के लिए पर्याप्त बाइट्स बचाए होंगे।

— नील

3

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

vमुख्य कार्य है, एक Stringतर्क देना और एक Stringपरिणाम देना।

v i=unlines.r$i++(' '<$i)
r""=[]
r s|t<-init s=(s++reverse t):map(' ':)(r t)

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

i प्रारंभिक तर्क / इनपुट है।
sप्रारंभ iमें length iरिक्त स्थान के साथ है।
v iकॉल करता है r s, फिर परिणाम लाइनों में शामिल होता है।
rStringलाइनों की एक सूची देता है ।
tहै sकाटा पिछले चरित्र के साथ।
पुनरावृत्ति r tपहले को छोड़कर लाइनों का उत्पादन करती है, प्रत्येक लाइन पर प्रारंभिक स्थान को घटाती है।

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

2

मुख्य कार्य के नामकरण के लिए +1 v। : डी

— DJMcMayhem

1

@DJMcMayhem: मुख्य फ़ंक्शन का नामकरण एक बाइट लंबा नहीं है unlines.r.((++)<*>(' '<$)):।

— नीमी

1

@ निम्मी मैं मानती हूं कि उसे पसंद है कि मैंने कौन सा नाम चुना। तकनीकी रूप से एक लंबोदर संबंध ... जब मैंने उत्तर लिखा था, मुझे नहीं पता था कि आप कुछ कार्यों के लिए शीर्ष स्तर की घोषणाओं का उपयोग कर सकते हैं, लेकिन मुख्य फ़ंक्शन का नाम नहीं। हालाँकि मैंने किसी और को ऐसा करते हुए देखा, मुझे यह कुछ परेशान करने वाला लगा। इन दिनों यह GHCi में कम से कम काम करता है।

— अप्रैल को अर्जन जोहान्सन

3

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

⁶ṁ;@µḣJUz⁶ŒBY

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

कैसे?

⁶ṁ;@µḣJUz⁶ŒBY - Main link: string s
⁶             - space character
 ṁ            - mould like s: len(s) spaces
  ;@          - concatenate s with that
    µ         - monadic chain separation (call that t)
      J       - range(length(t))
     ḣ        - head (vectorises): list of prefixes from length to all
       U      - upend: reverse each of them
        z     - transpose with filler:
         ⁶    -     space: now a list of the left parts plus centre
          ŒB  - bounce each: reflect each one with only one copy of the rightmost character
            Y - join with line feeds
              - implicit print

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

एक जैसे दिमाग महान सोचते हैं। : पी

— डेनिस

ओह, मैं एक संचयी संघटन के बारे में नहीं सोचा था! चारकोल में एक वी दिशा है, शायद कुछ जांच के स्थान ...

— जोनाथन एलन

3

रूबी, 85 83 बाइट्स

संपादित करें: अतिरिक्त व्हाट्सएप को हटा दिया

s=ARGV[0];s+=' '*s.length;s.length.times{|i|puts s+s[i..-2].reverse;s=' '+s[0..-2]}

मैं वास्तव में रूबी में यह एक नीचे गोल्फ के लिए बहुत मुश्किल पाया। व्हॉट्सएप जोड़ने के बाद, यह कोड के एक बहुत ही पठनीय स्निपेट में फैलता है:

s = ARGV[0]
s+=' ' * s.length

s.length.times do |i|
  puts s + s[i..-2].reverse
  s = ' ' + s[0..-2]
end

— Sculper
स्रोत

1

तुम शायद एक चर की तरह थोड़ा बचा सकता है। जैसा कि मैंने किया था? इसके अलावा, मुझे लगता है कि आपको लंबाई के बजाय आकार करने पर विचार करना चाहिए?

— user3334690

क्या कर रहे हैं @ user3334690 ने सुझाव दिया और .times स्टेटमेंट को आगे बढ़ाते हुए, 79 बाइट्स:s=ARGV[0];(s+=' '*s.size).size.times{|i|puts s+s[i..-2].reverse;s=' '+s[0..-2]}

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

आप इसे एक मेमना बनाकर पाँच बाइट्स बचा सकते हैं ।

— जॉर्डन

3

MATLAB (R2016b), 223 183 बाइट्स

r=input('');l=nnz(r)*2;for i=1:l;m=l+1-2*i;c={' '};s=cell(1,i-1);s(:)=c;x=cell(1,m);x(:)=c;e=r;y=flip(r);if(m<1);e=r(1:2*end-i+1);y=r(l/2+end-i:-1:1);end;disp(cell2mat([s e x y]));end

पहली बार कोड गोल्फिंग। सुझावों का स्वागत है!

कार्यक्रम का आउटपुट:

संपादित करें:

लुइस मेंडो के लिए धन्यवाद 40 बाइट्स बचाए।

— अनुदान मिलर
स्रोत

2

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

— मिलेंगे

1

इसके एन्कोडिंग उद्धरण सहित एक स्ट्रिंग इनपुट करना डिफ़ॉल्ट रूप से अनुमत है। तो आप 's'से हटा सकते हैं input। इसके अलावा, मैं यह नहीं देखता कि आप क्यों उपयोग कर रहे हैं evalc(disp(...)), लेकिन मुझे लगता है कि आप cell2mat इस तरह से

— लुइस मेंडो

1

इसके अलावा, इससे flipछोटा है end:-1:1, यहां

— लुइस मेंडो

3

PHP, 95 92 85 80 78 77 बाइट्स

नोट: IBM-850 एन्कोडिंग का उपयोग करता है

for($s.=strtr($s^$s=$argn,~ ,~▀);~$s[$i++];)echo$s,strrev($s=" $s"^$s^$s),~§;
          # Note that this ^ char is decimal 255 (negating it yields "\0")

इस तरह से चलाएं:

echo "Hello" | php -nR 'for($s.=strtr($s^$s=$argn,"\0",~▀);~$s[$i++];)echo$s,strrev($s=" $s"^$s^$s),~§;'
> Hello         olleH 
>  Hello       olleH  
>   Hello     olleH   
>    Hello   olleH    
>     Hello olleH     
>      HellolleH      
>       HellleH       
>        HeleH        
>         HeH         
>          H

व्याख्या

for(
  $s.=strtr(             # Set string to the input, padded with spaces.
    $s^$s=$argn,         # Input negated with itself, leads to string with
                         # only null bytes with the same length.
    ~ ,                  # Replace null bytes...
    ~▀                   # ... with spaces.
  );
  ~$s[$i++];             # Iterate over the string by chars, works because 
                         # there are just as many lines as the padded
                         # string has chars.
)
  echo                   # Output!
    $s,                  # The string.
    strrev(              # The reverse of the string.
      $s=" $s"^$s^$s     # After each iteration, prefix string with a
    ),                   # space, and trim the last character.
    ~§;                  # Newline.

बदलाव

पैड चरित्र से छुटकारा पाने के लिए 3 बाइट्स बचाए ( str_padअंतरिक्ष में चूक, जो हमें चाहिए)
इसके बजाय इसे छोटा करने के लिए स्ट्रिंग पर बाइनरी संचालन का उपयोग करके 7 बाइट्स सहेजे गए substr
रिवर्स प्रिंट करते समय स्ट्रिंग को घुमाकर 5 बाइट्स बचाए। बैकस्पेस प्रिंट करने की आवश्यकता को रोकता है, लेकिन प्रत्येक पंक्ति में एक अनुगामी स्थान होता है।
अधिक क्यूट, लेकिन कम विधि का उपयोग करके स्ट्रिंग को पैडिंग करके 2 बाइट्स सहेजे गए।
इस तथ्य के कारण एक बाइट को बचाया कि ~"0"मामले (एएससीआईआई 207) के लिए खाते की आवश्यकता नहीं है , क्योंकि सभी इनपुट को प्रिंट करने योग्य एएससीआई (Thx @Titus) माना जा सकता है

— aross
स्रोत

echo$s,strrev($s=" $s"^$s^$s),~§;5 बाइट्स बचाता है।

— तैतस

@ टिट्स, thx। आमतौर पर मैं

— व्हाट्सएप पर जाने से बचता

~$s[$i++]पर्याप्त है (इनपुट मुद्रण योग्य ASCII है, और ऐसा ही है $s)

— टाइटस

@ टिट्स, thx, अच्छी पकड़। मैं सुरक्षित पक्ष पर कोड करता

— हूं

2

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

(-10 बाइट्स कॉनर ओ'ब्रायन को धन्यवाद)

V=(j,i=0,p="")=>i<(f=j.length)*2?V(j,-~i,p+" ".repeat(i)+j.slice(0,f-i*(i>f))+" ".repeat(i<f?(f-i)*2-1:0)+[...j.slice(0,f+~i*(i>=f))].reverse().join``+`
`):p

एक पुनरावर्ती समाधान। मैं जावास्क्रिप्ट के लिए नया हूँ, इसलिए कृपया कोमल रहें! किसी भी गोल्फिंग टिप्स की बहुत सराहना की जाती है। :)

और, निश्चित रूप से, आपको जन्मदिन की बहुत-बहुत शुभकामनाएँ V!

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

V=(j,i=0,p="")=>i<(f=j.length)*2?V(j,-~i,p+" ".repeat(i)+j.slice(0,f-i*(i>f))+" ".repeat(i<f?(f-i)*2-1:0)+[...j.slice(0,f+~i*(i>=f))].reverse().join``+`
`):p

<input oninput=o.textContent=V(this.value)><pre id=o>

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

— आर। कप
स्रोत

1

यह बहुत अच्छा है! आमतौर पर, s.split("")को बदला जा सकता है [...s], और पीछे जोड़ी की एक जोड़ी a.join("")बन सकती है a.join। आप एक अतिरिक्त 3 बाइट्स को बदलकर [r='repeat']और [r]सादे ओल के साथ, उसी के साथ दोहरा सकते हैं slice।

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

@ ConorO'Brien सुझावों के लिए धन्यवाद! उनकी काफी तारीफ हो रही है। :)

— आर। कप

2

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

आपके पुराने पाल सीजम को जन्मदिन की शुभकामनाएँ!

q_,2*:L,\f{LS*+m>L<_W%(;N}

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

व्याख्या

q                           Push the input
 _,2*:L                     Push 2 times the length of the input, store it in L
       ,                    Take the range from 0 to L-1
        \                   Swap top stack elements
         f{                 Map over the range, using the input as an extra parameter
           LS*+               Append L spaces to the input
               m>             Rotate the resulting string right i positions (where i is the
                               current number being mapped)
                 L<           Take the first L characters of the string
                   _W%        Duplicate it and reverse it
                      (;      Remove the first character from the copy
                        N     Add a newline
                         }  (end of block)
                            (implicit output)

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

2

PowerShell, 126 बाइट्स 124 बाइट्स

$l=($s="$args")|% Le*;$r=-join$s[-1..-$l];0..($l*2-1)|%{' '*$_+($s+' '*$l).substring(0,$l*2-$_)+(' '*$l+$r).substring($_+1)}

एकल पैरामीटर के साथ इसे कॉल करें, जैसे कि .\V.ps1 Hello।

संपादित करें: AdmBorkBork से टिप के साथ सहेजे गए 2 बाइट्स

— टो
स्रोत

1

A इसे ऑनलाइन आज़माएं! लिंक, मामले में आप रुचि रखते हैं।

— डेनिस

ओह, मैं उस छोटे उपकरण के बारे में नहीं जानता था, धन्यवाद!

— Tor

नमस्ते! सामने की ओर एक छोटा गोल्फ। इनपुट को एक स्ट्रिंग के रूप में लें, और चर को पास करने के लिए इनकैप्सुलेशन का उपयोग करें। दो बाइट बचाता है। $l=($s="$args")|% Le*;

— AdmBorkBork

वाह, उन 2 गोल्फ के बारे में पता नहीं था, धन्यवाद!

— Tor

2

पाइके , 14 बाइट्स

l}j Fd*R+j^j<s

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

— नीला
स्रोत

2

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

f=(s,y=0,x=0,l=s.length*2-1)=>(s[(x>l?l*2-x:x)-y]||' ')+(x<l*2?f(s,y,x+1):y<l?`
`+f(s,y+1):'')

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

कोड स्निपेट दिखाएं

f=(s,y=0,x=0,l=s.length*2-1)=>(s[(x>l?l*2-x:x)-y]||' ')+(x<l*2?f(s,y,x+1):y<l?`
`+f(s,y+1):'')

console.log(f('Happy'))
console.log(f('Birthday'))
console.log(f('V!'))
console.log(f('~'))

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

— Arnauld
स्रोत

2

जे, 44 बाइट्स

(([(,}.@|.)@{."1-@i.@[|."0 1(,#&' ')~)~+:@#)

— मार्क एलन
स्रोत

1

हम्म, मैं यह कैसे ऑनलाइन चलाने के लिए समझ नहीं सकता। इसे ऑनलाइन आज़माएं! क्या मैं इसे गलत कह रहा हूं? (मैं एक जे

— नवाब हूं

@DJMcMayhem यह एक फ़ंक्शन है, एक कार्यक्रम नहीं है। tio.run/nexus/…

— डेनिस

गोल्फ: |."0 1करने के लिए |."{(बचाया 2 बाइट्स)

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

इसके अलावा, आपके पास बाहरी कोष्ठक नहीं हैं।

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

जन्मदिन मुबारक हो वी!

MATL , 21 14 बाइट्स

व्याख्या

टिप्पणी कोड

वी , 24, 23 , 20 बाइट्स

ब्रेनफक , 152 बाइट्स

टिप्पणियों के साथ

> <> , 221 बाइट्स

उदाहरण

व्याख्या

ब्रेन-फ्लैक , 486 + 1 = 489 बाइट्स

व्याख्या

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

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

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

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

जावास्क्रिप्ट (ईएस 6), 108 106 98 94 बाइट्स

रेटिना , 51 47 बाइट्स

व्याख्या

05AB1E , 12 बाइट्स

जाप, २२ २० १६ १४ + २ बाइट्स

व्याख्या

GNU सेड , 110 100 + 1 (आर झंडा) = 101 बाइट्स

अजगर, 110 बाइट्स

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

व्याख्या

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

व्याख्या

पिप , 32 25 बाइट्स

व्याख्या

आर स्ट्रिंग पैकेज के साथ, 225 बाइट्स

स्पष्टीकरण:

रूबी, 92 89 85 बाइट्स

बैच, 186 185 बाइट्स

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

टिप्पणियाँ:

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

कैसे?

रूबी, 85 83 बाइट्स

MATLAB (R2016b), 223 183 बाइट्स

PHP, 95 92 85 80 78 77 बाइट्स

व्याख्या

बदलाव

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

टेस्ट स्निपेट

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

PowerShell, 126 बाइट्स 124 बाइट्स

पाइके , 14 बाइट्स

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

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

जे, 44 बाइट्स