एक ASCIIrisk ड्रा करें

Question

तारांकन का उपयोग करते हुए ड्राइंग आकृतियों से संबंधित प्रश्नों की एक बहुतायत है - इसलिए मैंने सोचा, इतने सारे तारांकन के साथ, हमें एएससीआईआई तालिका का उपयोग करके एक ड्रा करना चाहिए।

चुनौती

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो कोई इनपुट नहीं लेता है, और इस सटीक पाठ को आउटपुट करता है:

          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

संदर्भ के लिए, यह साइट पूरी ASCII तालिका को सूचीबद्ध करती है।

नियम

• आउटपुट सटीक पाठ होना चाहिए, जैसा कि ऊपर दिखाया गया है। व्हाट्सएप पर अग्रणी / अनुगामी की अनुमति है।
• स्टैंडर्ड गोल्फिंग लूपहोल्स लागू होते हैं - इंटरनेट से इस ASCIIrisk को नहीं पढ़ना, आदि।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा समाधान (बाइट्स में) जीतता है।

Comments

मैं इस चुनौती का प्रयास करना चाहता हूं ... लेकिन यह थोड़े जोखिम भरा है । कृपया मेरे भयानक हास्य का बहाना करें।

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

स्टैक ओवरफ्लो में NoBadJokes पॉलिसी है, इसलिए मुझे उस टिप्पणी को अनदेखा करना होगा। क्षमा करें, लेकिन यह नीति

ठीक है। पॉलिसी का उल्लंघन करने के लिए क्षमा करें। इसका जवाब देकर मेरी टिप्पणी को अनदेखा करने के लिए धन्यवाद।

— हाइपरएन्यूट्रीनो

Answer 1

05AB1E , 40 38 37 36 35 बाइट्स

žQ2ô376S3*£`2ôvyN·ð×ýð«}rsJ2äsr)˜.c

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

व्याख्या

žQ                                   # push the printable ascii chars
  2ô                                 # split into pairs
    376S                             # split the number 376 into a list of digits
        3*                           # multiply each by 3 to get [9,21,18]
          £                          # divide the pairs of ascii chars into 
                                     # pieces of these sizes
           `                         # flatten list to stack
            2ô                       # split the "legs" of the asterisk into pairs of pairs
              v                      # loop over the pairs of pairs
               yN·ð×ý                # join the pairs by index*2 spaces
                     ð«              # append a space
                       }             # end loop
                        rs           # move the middle section to top of stack
                          J2ä        # convert to a string split into 2 pieces
                             sr      # rearrange the stack in the correct order
                               )˜    # wrap in a flattened list
                                 .c  # pad each element with spaces on either side

Comments

žQ2ôÐ9£s30£R21£RøsrR18£R2ôvyN·ð×ý})˜.C», मुझे 39 मिले, लेकिन मुझे लगता है कि आप जिप के साथ कुछ शेव कर सकते हैं।

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

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

— एमिग्ना

Answer 2

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

s='%c';print(('\n'.join(['%10c%c']*9+[s*21]*2+[' '*(8-i)+s*2+'  '*i+s*2for i in range(9)]))%(*range(32,128),))

टेम्पलेट तैयार करता है

         xx
         xx
         xx
         xx
         xx
         xx
         xx
         xx
         xx
xxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxx
        xxxx
       xx  xx
      xx    xx
     xx      xx
    xx        xx
   xx          xx
  xx            xx
 xx              xx
xx                xx

साथ %cके लिए x, तो पर स्ट्रिंग प्रक्षेप का उपयोग करता है range(32,128)पैटर्न में ASCII मूल्यों डालने के लिए।

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

पाइथन 2 एक बाइट लंबी है, जिसमें टपल अनपैकिंग लेकिन छोटी है print।

s='%c';print('\n'.join(['%10c%c']*9+[s*21]*2+[' '*(8-i)+s*2+'  '*i+s*2for i in range(9)]))%tuple(range(32,128))

Comments

यह एक एफिल टॉवर समानता पुरस्कार के योग्य है!

— सर्गिओल

Answer 3

वी , 54 , 50 बाइट्स

¬ ~9ñ9É 11|á
ñ2ñ20lá
ñ$18é 9ñ^y|Ehé
Pf xxywk$hP>ñd

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

सामान्य के विपरीत, इस कार्यक्रम में कोई भी वर्ण नहीं है।

स्पष्टीकरण:

¬ ~                     " Insert the entire printable ASCII range
   9ñ           ñ       " 9 times:
     9É                 "   Insert 9 spaces at the beginning of this line
        11|             "   Move to the 11'th column on this line
           á<CR>        "   And append a newline after the 11'th column

अब बफर इस तरह दिखता है:

          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

अब हम बीच का निर्माण करते हैं:

2ñ        ñ             " Two times:
  20l                   "   Move 20 characters to the right (because 'l' == 'right', duh)
     á<CR>              "   Append a newline

यहाँ है जहाँ यह थोड़ा अजीब हो जाता है।

$                       " Move to the end of this line 
 18é                    " Insert 18 spaces before the last character
     9ñ                 " Repeat the following 9 times:
       ^                "   Move to the first non-whitespace character
        y|              "   Yank all the whitespace before the current character. 
                        "   We'll call this the "Leading whitespace register"
          E             "   Move to the end of the current WORD (up to before a space)
           h            "   Move back one character
            é<CR>       "   And insert a newline before the current character
P                       "   Paste the leading whitespace for indentation
 f                      "   Move forward to a space
   xx                   "   Delete two characters
                        "   (Note how we are inbetween the two bottom branches right now)
     yw                 "   Yank everything upto the next branch (all spaces)
                        "   We'll paste this on the line up so that we can yank it again later
                        "   To keep track of how far apart the branches are
       k$               "   Move up a line and to the end of that line
         hP             "   Move back a character and paste the whitespace we yanked
           >            "   Indent this line by one space
            ñ           "   End the loop

यहाँ एक महत्वपूर्ण नोट है। >आदेश वास्तव में एक है ऑपरेटर , पर संचालित करने के लिए पाठ यह एक बहस के बिना कुछ भी नहीं है जिसका अर्थ है,। उदाहरण के लिए,

>_      "Indent the current line
>>      "Indent the current line
>j      "Indent the current and next line
>G      "Indent every line

लेकिन चूंकि यह कमांड एक लूप में है, इसलिए हम ऑपरेटर नहीं देकर एक चरित्र को बचा सकते हैं। एक लूप के अंत में, यदि कोई ऑपरेटर लंबित है, तो वह भर जाएगा_ तर्क (वर्तमान लाइन) को एक तर्क के रूप ।

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

यदि आप इसे 9 पर सेट करते हैं, तो आप देख सकते हैं कि हमारे पास छुटकारा पाने के लिए थोड़ा अतिरिक्त पाठ है। (बस वर्तमान लाइन)।

इसलिए हम वर्तमान लाइन को हटाते हैं dd। लेकिन रुकें! आप जानते हैं कि मैंने कैसे कहा कि ऑपरेटरों को एक तर्क लेना है जो कुछ समय में निहित है? तर्क भी कार्यक्रम के अंत में निहित हैं। तो इसके बजाय ddया d_(जो समतुल्य हैं), हम बस हमारे लिए dवी भर सकते हैं और जाने देंगे _।

Comments

अच्छा काम निहितार्थ का दुरुपयोग करते हुए ÿ:)

— क्रिति लिथोस

Answer 4

पायथन 3 170 165 155 147 बाइट्स

मैंने इसे इतना बड़ा किया है, मैं भूल गया हूं कि यह कैसे काम करता है ...

i=b=0
for x in range(32,127):a=x%2<1;c=x>90;d=x<50;print(end=[' '*9*d,['\n'+' '*(8-i),'  '*~-i][b]][c]*a+chr(x)+'\n'*(x==70or d*x%2));b^=a;i+=b*c*a

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

Answer 5

जावास्क्रिप्ट (ईएस 6), 156 … 115 114 बाइट्स

अफसोस की बात है कि कुख्यात की String.fromCharCode()कीमत 19 बाइट है।

f=(x=y=k=1)=>k<96?String.fromCharCode(x-22?y/2^5&&(y>9?x-y+1>>1&&22-y-x>>1:x/2^5)?32:31+k++:(x=!++y,10))+f(x+1):''

console.log(f())

प्रारूपित और टिप्पणी की गई

f = (                         // given:
  x =                         //   - x = current column
  y =                         //   - y = current row
  k = 1                       //   - k = current ASCII character code, minus 31
) =>                          //
  k < 96 ?                    // if we havent't reached character #127 (96 + 31):
    String.fromCharCode(      //   let's compute the next character
      x - 22 ?                //   if x is not equal to 22 (end of line):
        y / 2 ^ 5 && (        //     if y doesn't equal 10 or 11 (horizontal bar):
          y > 9 ?             //       and either y is greater than 9:
            x - y + 1 >> 1 && //         and we are not located on one of the
            22 - y - x >> 1   //         bottom diagonals
          :                   //       or y is less or equal to 9:
            x / 2 ^ 5         //         and x doesn't equal 10 or 11 (vertical bar)
        ) ?                   //     then:
          32                  //       append a space
        :                     //     else:
          31 + k++            //       append the next ASCII character
      :                       //   else:
        (x = !++y, 10)        //     increment y, reset x and append a LineFeed
    ) + f(x + 1)              //   do a recursive call with x + 1
  :                           // else:
    ''                        //   stop recursion

Comments

मुझे लगता है कि आप String.fromCharCode(...[...Array(n)].map(_=>k++))4 बाइट बचाने के लिए कर सकते हैं ।

— ETHproductions

@ETHproductions मुझे String.fromCharCode()एक सरणी पर कॉल करने का विचार पसंद है , लेकिन मैं दूसरे दृष्टिकोण के लिए गया था। फिर भी धन्यवाद!

— अरनौलद

Answer 6

QBIC , 153 151 बाइट्स

[32,49,2|?space$(9)+chr$(a)+chr$(a+1)][2|X=Y[a,a+20|X=X+chr$(c)]a=a+21?X][0,8|X=space$(8-d)[0,1|X=X+chr$(a+e)]X=X+space$(d*2)[2,3|X=X+chr$(a+f)]a=a+f?X

यह वास्तव में फॉर-लूप्स की एक श्रृंखला है और एक इंट को एक चरित्र ( chr$()) में डालना है ।

नमूना उत्पादन:

          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

Answer 7

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

कोड + -lध्वज के 112 बाइट्स ।

sub g{chr$c+++32}print$"x9,&g,&g for 0..8;print map&g,0..20for 0,1;print$"x-$_,&g,&g,$"x(16+2*$_),&g,&g for-8..0

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

Answer 8

PHP, 110 105 103 93 91 बाइट्स

for(;$c<95;$y+=!$x%=21)echo"
"[$x],chr(31+($y%11<9&(max($y,10)-abs(9.5-$x++))%11<9?:++$c));

एक प्रमुख न्यूलाइन प्रिंट करता है। इसे ऑनलाइन चलाएं -nrया परीक्षण करें ।

मूल सिद्धांत अर्नुलद से अपनाया गया है, लेकिन यह पुनरावृत्त करता है।
और यह PHP के निहित टाइपकास्ट से अच्छा फायदा उठाता है:
स्ट्रिंग इंडेक्स के लिए एनएलटी , इंट के लिए फ्लोट %, इन के लिए बूलियन और इंट के &लिए +=।

छद्म कोड के साथ स्पष्टीकरण

If $x is 0, print a newline. ("\n"[$x] is newline for $x=0; empty for every larger $x)
if $y is neither 9 nor 10 (not middle part: $y<9|$y>10 <=> $y%11<9)
AND distance to center == abs(9.5-$x) (in [0.5,1.5,..,10.5]) ->
    lower part:     abs($y-10-distance)>1                   => ($y-distance)%11<9
                (this works because $y is always <20)
    upper part: $x<9|$x>10 <=> distance>1 <=> 10-distance<9 => (10-distance)%11<9
                (this works because % has negative results for negative first operands)
    both parts: $y>9?$y:10 <=> max($y,10)
// $a?:$b evaluates to $a if $a is truthy, to $b else
// and the ternary condition evaluates to 1 if the coords are not in the shape
then print chr(31+1) = space
else print chr(31+incremented $c)

Answer 9

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

js.e@[+L*9;cb2c2b.e+*-8Ydj*yYdZcL2cb4)kcsrdC127,18 60

एक प्रोग्राम जो परिणाम प्रिंट करता है।

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

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

srdC127 मुद्रण योग्य ASCII वर्णों की एक सूची बनाता है और इसे एक स्ट्रिंग में सम्मिलित करता है।

c....,18 60सूचकांकों पर इस स्ट्रिंग को विभाजित करता है 18और 60आउटपुट के विभिन्न भागों के अनुरूप तीन तारों की सूची देता है: शीर्ष, मध्य और नीचे।

.eके रूप में bऔर उनके सूचकांक के रूप में तार के साथ तार पर एक enumerated नक्शा शुरू होता है k।

[...)आरेख के प्रत्येक भाग के लिए वांछित कार्रवाई वाली एक सूची बनाता है। सही क्रिया का उपयोग करके वर्तमान सूचकांक के साथ सूची में अनुक्रमण द्वारा चुना जाता है @...k।

• चोटी

  cb2पात्रों के जोड़े, और में स्ट्रिंग विभाजन +L*9;पहले जोड़ता 9प्रत्येक जोड़ी के लिए रिक्त स्थान।

• मध्य

  c2b स्ट्रिंग को दो समान लंबाई वाले तारों में विभाजित करता है।

• तल

  cL2cb4 स्ट्रिंग को चार वर्णों के समूह में विभाजित करता है, और प्रत्येक समूह को जोड़े में।

  .eस्ट्रिंग जोड़े के रूप में Zऔर उनके सूचकांकों के साथ, एक संकलित नक्शा शुरू करता है Y।

  j*yYdZ2*Yरिक्त स्थान पर जोड़े +*-8Ydजोड़ता है , और 8-Yरिक्त स्थान को प्रीपेन्ड करता है।

jsसभी परिणामों को मर्ज करता है और परिणामस्वरूप नई सूची में शामिल होता है। यह तो स्पष्ट रूप से मुद्रित है।

Answer 10

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

b!n=[1..n]>>b
('*':r)#(a:s)=a:r#s
(a:r)#s=a:r#s
r#s=r
p="**"
f=unlines([" "!9++p]!9++["*"!21]!2++[" "!(8-n)++p++" "!(2*n)++p|n<-[0..8]])#[' '..]

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

स्पष्टीकरण:

b!n=[1..n]>>bएक फ़ंक्शन को परिभाषित करता है !जो एक सूची या स्ट्रिंग b n-टाइम्स को दोहराता है ।

unlines([" "!9++p]!9++["*"!21]!2++[" "!(8-n)++p++" "!(2*n)++p|n<-[0..8]]) तारांकन (ओह, विडंबना!) के तार खींचने के लिए इस फ़ंक्शन का उपयोग करता है:

         **
         **
         **
         **
         **
         **
         **
         **
         **
*********************
*********************
        ****
       **  **
      **    **
     **      **
    **        **
   **          **
  **            **
 **              **
**                **

#एक फ़ंक्शन के रूप में परिभाषित किया गया है जो लगातार *दी गई सूची से वर्णों के साथ एक स्ट्रिंग में बदलता है। यह तारांकन के उपरोक्त तार के साथ कहा जाता है और [' '..]जो अंतरिक्ष से शुरू होने वाले सभी पात्रों की एक अनंत सूची है ' '।

Comments

यहाँ पार्टी के लिए सुपर लेट, लेकिन वह " "!(2*n)हो सकता है "(TWO SPACES)"!n।

— लिन

Answer 11

चारकोल , 39 बाइट्स (नॉनकमेटिंग)

ＧＨ↑χ→⁴↓χ→¹¹↓⁴←χ↘χ←⁴↖⁹←²↙⁹←⁴↗χ←⁹↑⁴→⁹ ↓¤γ

इसे ऑनलाइन आज़माएं! एएसटी स्पष्टीकरण के लिए प्रदान करता है, के χलिए पूर्वनिर्मित चर रहा है 10।

Answer 12

जे, ६३

(प्रतिस्पर्धा नहीं)

a.{~32>.31+20 21$(* +/\),(9 21&$@{.,1:,1:,}.)(+.1&|."1)|.=|i:10

अभिव्यक्ति इस प्रकार बाएं से दाएं मूल्यांकन करती है:

• i: 10 -10 से +10 तक गिना जाता है
• | +10 को 0 से वापस पाने के लिए abs को +10 पर ले जाएं
• = स्वयं को 0 के एक ब्लॉक में 1 के वी आकार प्राप्त करने के लिए वर्गीकृत करें
• |. / पाने के लिए रिवर्स रो ऑर्डर
• ( +. 1&|."1 ) हुक अभिव्यक्ति प्रत्येक पंक्ति को एक ओर और मूल के साथ सही स्थानांतरित करता है
• ( 9 21&$@{. , 1: , 1: , }. ) नेस्टेड कांटे क्षैतिज और खिंचाव शीर्ष में डाल दिया
• , संचयन के लिए एक रेखीय अनुक्रम में ब्लॉक को रोकना
• ( * +/\ ) स्वयं के साथ संचयी और गुणा करें
• 20 21 $ 21 तत्वों की 20 पंक्तियों को ब्लॉक करने के लिए आकृति को वापस लाएं
• 31 + 31 जोड़ें क्योंकि पहले 1 में एक स्पेस चार कोड 32 होना चाहिए
• 32 >. 32 पर मंजिल
• a. {~ एएससी से निर्मित में चार्ट चुनें

Comments

PPCG में आपका स्वागत है! कैसे आप इसे प्रतिस्पर्धा नहीं के रूप में चिह्नित करते हैं?

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

मैंने सोचा था कि प्रतियोगिता शुरू होने के बाद [१५ मिनट] लंबे समय के बावजूद मैं अपना प्रयास जोड़ूंगा .. क्या आप कह रहे हैं कि प्रत्येक पहेली खुली रहती है? .. J अभिव्यक्ति के लिए भी REPL के बाहर मुद्रित करने के लिए, यानी जब एक स्क्रिप्ट में निष्पादित मैं उपसर्ग smoutputकमांड या समकक्ष की आवश्यकता होगी

— jayprich

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

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

Answer 13

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

->{(-11..8).map{|i|["%s"*21,"%#{9-i}s%s%#{i*2+1}s%s","%10s%s"][i/2<=>-1]}*$/%[*' '..?~,$/]}

Ungolfed

->{(-11..8).map{|i|            #For each line
  ["%s"*21,                    #If i/2==-1 make a format string of 21 %s
   "%#{9-i}s%s%#{i*2+1}s%s",   #If i/2>-1 make a format string %{9-i}s%s%{i*2+1}s%s
   "%10s%s"][i/2<=>-1]         #If i/2<-1 make a format string %10s%s
  }*$/%                        #Join the format strings with newlines $/ then use sprintf operator %
  [*' '..?~,$/]                #to replace the %s with *' '..'~' and a newline for last corner.
}

Answer 14

मुझे C # में एक उत्तर याद आया ...

सी # (.NET कोर) , 175 174 बाइट्स

_=>{var r="";for(int i=0,j,d=32,s=1;i<54;i++)for(j=0;j++<"*#4#4#4#4#4#4#4#4#+K)%1###/#%#-#'#+#)#)#+#'#-#%#/###1#"[i]-33;)r+=(char)(i%2<1?32:d++)+(s++%21<1?"\n":"");return r;}

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

• 1 बाइट केविन क्रूज़सेन की बदौलत बचा!

Comments

आप intएस-फॉर-लूप के अंदर लगाकर एक बाइट बचा सकते हैं :for(int i=0,j,d=32,s=1;i<54;i++)for(j=0

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

Answer 15

टीईसी , 209 बाइट्स

proc I {} {incr ::i}
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [[set F format] %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr 32-[I]/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

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

---

टीईसी , 212 बाइट्स

proc I {} {incr ::i}
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [[set F format] %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr (129-[I])/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

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

tcl, 213

proc I {} {incr ::i}
set F format
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr (129-[I])/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

डेमो

---

tcl, 214

proc I {} {incr ::i}
set F format
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
A
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

डेमो

---

tcl, २२cl

proc I {} {incr ::i}
set F format
proc A {} {time {append ::a [$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

डेमो

tcl, 236

proc I {} {incr ::i}
set F format
proc A {} {time {append ::a [$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

डेमो

---

tcl, 237

proc I {} {incr ::i}
set F format
proc A {} {time {set ::a $::a[$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

डेमो

---

एक ही आकार के साथ वैकल्पिक दृष्टिकोण:

proc I {} {incr ::i}
set F format
proc A b {time {upvar $b c;set c $c[$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A a
set a $a\n
A a
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

डेमो

Tcl, 288

lassign {set while puts format incr expr} S W P F I E
$S i 31
$W \$i<48 {$P [$F %10c%c [$I i] [$I i]]}
$S a ""
$W {[$I i]<71} {$S a $a[$F %c $i]}
$S a $a\n
$W \$i<92 {$S a $a[$F %c $i];$I i}
$P $a
$W \$i<128 {$P [$F %[$E (129-$i)/4]c%c $i [$I i]][$F %[$E $i/2-45]c%c [$I i] [$I i]]; $I i}

डेमो

---

tcl, 297 बाइट्स (भोले प्रयास)

set i 31
while \$i<48 {puts [format %10c%c [incr i] [incr i]]}
set a ""
while {[incr i]<71} {set a $a[format %c $i]}
set a $a\n
while \$i<92 {set a $a[format %c $i];incr i}
puts $a
while \$i<128 {puts [format %[expr (129-$i)/4]c%c $i [incr i]][format %[expr $i/2-45]c%c [incr i] [incr i]]; incr i}

डेमो

Comments

"भोले प्रयास" से आपका क्या अभिप्राय है? क्या आपको इसके बजाय शीर्षक में लंबाई नहीं डालनी चाहिए?

मेरा मतलब है कि इसे और अधिक गोल्फ के लिए जगह है, क्योंकि अभी भी बहुत दोहराव है। और मैं इसे और अधिक गोल्फ दूंगा।

— सर्जियोल

कच्चे दृष्टिकोण में 254 बाइट है।

— सर्जियोल

209

— केवल

@ ASCII- केवल: धन्यवाद। मेरा आपके सुझाव के बराबर नहीं है! ;)

— सर्गियोल

Answer 16

काव्य , 899 बाइट्स

ill be honest with you
i expect a big solitude
i guess i had a guilt
my own idea being:i was real alone,i was a lonely human
also,i am still
o,i guess i was expecting a shift
i figured,surely i know i am tired of silence
now i dreamed for a shift
a magical desire cant come
i am barely a man,so i guess i see why a woman i see ignores myself
i know i am awful
o,a night of passion and a moment of love
i am truly the foolish person,every time i am saying i may recapture a love
o,i think i can,i think i can
i really do know i am unfit
o,i notice a lot,i think i know i am unfit
o,a novel,or perhaps poetry in code,i do enjoy the writing
and i shudder and i wonder in a moment
i was a weirdo,i was a freak,or like,i am creepy
o,i think i was a misfit
i know i am,really
o,i ought not concern myself
and sure,i am still some joyless man
i focused and i tried
a lasting solace and joy is nearby for me

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

काव्यात्मक एक एस्लांग है जो मैंने 2018 में एक क्लास प्रोजेक्ट के लिए बनाया था। यह मूल रूप से प्रतीकों के बजाय शब्द-लंबाई के साथ दिमाग है।

यह कविता ... निराशाजनक है। 😟

Answer 17

पायथन 2.7, 194 188 बाइट्स

k,l,c,s,r=8,0,chr,' ',range;o=''.join(map(chr,r(32,127)))
for i in r(0,18,2):print s*9+o[i:i+2]
print o[18:39]+'\n'+o[39:60]
for i in r(60,95,4):print s*k+o[i:i+2]+s*l+o[i+2:i+4];k-=1;l+=2

Comments

आप 2 बाइट्स को बदल map(chrसकते हैं map(cजैसे cकि पहले ही परिभाषित किया गया हैchr

Answer 18

Jq 1.5 , 180 बाइट्स

foreach((range(9)|[9,2]),(range(2)|[0,21]),(range(9)|[8-.,2,.+.,2]))as$r({s:[range(32;127)]|implode};.r=$r|.p=""|until(.r==[];.p+=" "*.r[0]+.s[:.r[1]]|.s =.s[.r[1]:]|.r=.r[2:]);.p)

विस्तारित

foreach (                              # instruction sequence: [indent, count]
    (range(9)|[9,2]),                  # 9 rows of 2 characters indented 9 spaces
    (range(2)|[0,21]),                 # 2 rows of 21 characters
    (range(9)|[8-.,2,.+.,2])           # 9 rows of 4 characters with varying indent
) as $r (
    {s:[range(32;127)]|implode}        # state = ascii string
  ; .r = $r                            # current instruction
  | .p = ""                            # print string for this row
  | until(.r==[];                      # until current instruction is exhausted
        .p += " "*.r[0] + .s[:.r[1]]   # add to print string
      | .s = .s[.r[1]:]                # remove from state
      | .r = .r[2:]                    # remove from instruction
    )
  ; .p                                 # emit print string
 )

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

Answer 19

स्लैश ( /// ), 324 बाइट्स

          !
         "#
         $%
         &'
         ()
         *+
         ,-
         .\/
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \\]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

स्लैश में पहली (डिफ़ॉल्ट) कार्रवाई 'प्रिंट' है, इसलिए स्ट्रिंग मुद्रित होती है। /और \आगे बढ़ने की सहायता से निकले किया जाना चाहिए \है।

Comments

आपको बाइट की गिनती और अधिमानतः एक दुभाषिया के लिए लिंक जोड़ना चाहिए। यह बजाय ungolfed लग रहा है (यकीन है कि अगर यह /// में बेहतर करने के लिए बेहतर है)।

— स्टीवी ग्रिफिन

यह /// की सुंदरियों को दिखाने के लिए कुछ मज़ाक है, और मैं उन्हें जोड़ूंगा!

— क्लैब 4545

Answer 20

जावा 8, 176 173 बाइट्स

v->{for(int i=0,j,d=32,s=1;i<54;i++)for(j=0;j++<"*#4#4#4#4#4#4#4#4#+K)%1###/#%#-#'#+#)#)#+#'#-#%#/###1#".charAt(i)-33;)System.out.printf(s++%21<1?"%c\n":"%c",i%2<1?32:d++);}

पोर्ट @Charlie की C # .NET उत्तर है , इसलिए उसे बनाए रखना सुनिश्चित करें।
-3 बाइट्स @ceilingcat की बदौलत ।

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