चुनौती

एक फ़ंक्शन या प्रोग्राम बनाएँ, जो पूर्णांक दिए जाने पर size, निम्न कार्य करता है:

यदि size1 के बराबर है, आउटपुट

H H
HHH
H H

यदि size1 से अधिक है, तो आउटपुट

X X
XXX
X X

जहां Xकार्यक्रम / समारोह के लिए उत्पादन होता हैsize - 1

(यदि आप चाहें, तो आपके पास आधार मामला हो सकता है 0, जब तक आप अपने उत्तर में निर्दिष्ट करते हैं)

निम्नलिखित आउटपुट स्वरूपों में से कोई भी स्वीकार्य है, जो भी आपके लिए अधिक सुविधाजनक है:

किसी भी दो अलग-अलग वर्णों के साथ आवश्यक संरचना की एक स्ट्रिंग जिसके अनुरूप Hऔरspace
आवश्यक संरचना के साथ एक दो आयामी सरणी, Hऔर इसी के साथ किसी भी दो अलग मूल्यों के साथspace
तार की एक सरणी / सूची, प्रत्येक स्ट्रिंग में आउटपुट की एक पंक्ति के साथ, Hऔर इसी के साथ दो अलग-अलग मानों के साथspace

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

निर्दिष्ट करें कि आपका कोड किस आउटपुट स्वरूप में लौट रहा है।

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

1

H H
HHH
H H

2

H H   H H
HHH   HHH
H H   H H
H HH HH H
HHHHHHHHH
H HH HH H
H H   H H
HHH   HHH
H H   H H

3

H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H HH HH HH HH HH HH HH HH H
HHHHHHHHHHHHHHHHHHHHHHHHHHH
H HH HH HH HH HH HH HH HH H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे कम बाइट की गिनती होती है!

code-golf ascii-art fractal code-golf code-golf string code-golf string matrix code-golf graph-theory maze binary-matrix code-golf kolmogorov-complexity random code-challenge metagolf test-battery brain-flak text-processing code-golf matrix code-golf number-theory primes code-golf string matrix code-golf binary bitwise code-golf number factorial floating-point code-golf number sequence code-golf sequence cops-and-robbers code-golf sequence cops-and-robbers code-golf string code-golf math decision-problem number-theory integer code-golf number decision-problem functional-programming code-golf array-manipulation matrix code-golf string classification string code-challenge binary compression decode code-golf string string code-challenge balanced-string encode code-golf number-theory integer base-conversion code-golf math number-theory geometry abstract-algebra code-golf array-manipulation sorting optimization code-golf math geometry image-processing generation code-golf string cops-and-robbers repeated-transformation grammars cops-and-robbers repeated-transformation grammars code-challenge restricted-source tips source-layout javascript code-challenge kolmogorov-complexity restricted-source code-golf combinatorics counting math fastest-code linear-algebra code-golf math permutations matrix linear-algebra code-golf string decision-problem restricted-source code-golf number array-manipulation subsequence code-golf number array-manipulation matrix code-golf brainfuck code-golf color code-golf quine source-layout code-golf subsequence code-golf string ascii-art code-golf string ascii-art alphabet code-golf decision-problem interpreter hexagonal-grid halting-problem code-golf string polynomials calculus code-golf math decision-problem matrix complex-numbers code-golf random code-golf number arithmetic

— Bazinga_9000
स्रोत

4

चारकोल के लिए एकदम सही ... शायद। PPCG में भी आपका स्वागत है! : D

— HyperNeutrino

10

PPCG में आपका स्वागत है। अच्छी पहली चुनौती!

— आदम

क्या हम 0 आधारित आकारों का उपयोग कर सकते हैं?

— आदम

3

वोल्फ्राम भाषा (गणितज्ञ) , 46 बाइट्स

Nest[ArrayFlatten@{r={#,0,#},{#,#,#},r}&,1,#]&

0S और 1s की 2d सरणी देता है ।

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

— alephalpha
स्रोत

17

Mathematica की पुनरावृत्ति नेस्टेड सरणियों के लिए बिल्ट-इन है। +1

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

1

@ हीपरनेट्रिनो अच्छी तरह से स्पष्ट रूप से

— केवल

7

@HyperNeutrino इसे एक अंतर्निहित कैसे माना जाता है? बस Nest(बार-बार) फ़ंक्शन कई बार। किसी भी अन्य सबमिशन (जेली?) की ArrayFlattenतरह ... अच्छी तरह से, बिल्ट-इन है, लेकिन यह Flatten[#,{{1,3},{2,4}}]इस मामले में कुछ हद तक व्यवहार करता है। (परीक्षण नहीं किया)

— user202729

6

इसके लिए एक अंतर्निहित है, लेकिन लंबे समय तक। मैथेमेटिका में लंबे फ़ंक्शन नाम हैं।

— एलेफाल्फा

1

यह कैसे नहीं हो सकता है, अपटगट चैलेंज पर अपनी जीत को देखते हुए ?

— ओजदो

21

कैनवस , 14 12 बाइट्स

H；［⌐⌐∔＊×∔；３＊＋

यहाँ यह कोशिश करो!

स्पष्टीकरण:

Code    |Instruction                                                         |Stack
--------+--------------------------------------------------------------------+-------------------------
        |Push input to stack (implicit)                                      |I
H       |Push "H" to stack                                                   |I,"H"
；      |Swap the top two stack items                                        |"H",I
［      |The following ToS (input) times:                                    |X
    ⌐⌐  |Duplicate ToS (result from last loop ("H" if first loop)) four times|X,X,X,X,X
    ∔   |Join vertically                                                     |X,X,X,X\nX
    ×   |Prepend                                                             |X,X,XX\nX
    ∔   |Join vertically                                                     |X,X\nXX\nX
    ；  |Swap top two stack items                                            |X\nXX\nX,X
    ３＊|Repeat three times vertically                                       |X\nXX\nX,X\nX\nX
    ＋  |Join horizontally                                                   |X<space>X\nXXX\nX<space>X
        |End loop (implicit)                                                 |X
        |Print ToS (implicit)                                                |

Iइनपुट कहां है, Xपिछले लूप (पहले लूप के लिए "एच") द्वारा उत्पन्न पैटर्न है , और पैटर्न <space>की पहली और तीसरी पंक्ति पर खाली स्थान है, इसके द्वारा निहित है ＋।

-2 बाइट्स dzaima को धन्यवाद !

— hakr14
स्रोत

आश्चर्यजनक रूप से संक्षिप्त उत्तर: O

— NL628

19

MATL , 12 11 बाइट्स

t:"[ACA]BX*

इनपुट को देखते हुए n, यह एक मैट्रिक्स युक्त आउटपुट 0और n।

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

इसे हेडर में एक वर्ण मैट्रिक्स Hऔर स्पेस ऐड g72*cमें परिवर्तित करने के लिए । इसे भी ऑनलाइन आज़माएं!

या ]1YCरेखांकन प्रदर्शित मैट्रिक्स को देखने के लिए जोड़ें । MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

t          % Input (implicit): n. Duplicate
:          % Range. Gives the array [ 1 2 ... n]
"          % For each (that is, do n times)
  [ACA]    %   Push the array [5 7 5]
  B        %   Convert to binary. Gives the 3×3 matrix [1 0 1; 1 1 1; 1 0 1]
  X*       %   Kronecker product
           % End (implicit). Display (implicit)

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

16

स्टैक्स , 16 15 बाइट्स

╛c_mê║6{│◙ÖmπV"

इसे चलाएं और डीबग करें

यह टिप्पणियों के साथ कार्यक्रम का एएससीआई प्रतिनिधित्व है। यह कार्यक्रम एच बग़ल में बनाता है, और फिर एक बार अंत में स्थानांतरित करता है।

'H]                 ["H"]
   {         },*    repeat block specified number of times
    c               copy the matrix
     {3*m           triplicate each row
         |S         surround; prepend and append like b + a + b
           |C       horizontally center rows with spaces
                M   transpose back to original orientation
                 m  output each row

बोनस 14 बाइट प्रोग्राम - आउटपुट इनपुट के रूप में इसके इनपुट का उपयोग करता है। सैद्धांतिक रूप से, यह 10 पर सही आकार का उत्पादन नहीं करेगा, क्योंकि इसमें 2 अंक हैं, लेकिन इसे चलाने का प्रयास मेरे ब्राउज़र को क्रैश कर देता है।

— पुनरावर्ती
स्रोत

11

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

आउटपुट स्ट्रिंग्स की एक सूची है, प्रति पंक्ति एक स्ट्रिंग।

f=->n{n<1?[?H]:[*a=(x=f[n-1]).map{|i|i+' '*i.size+i},*x.map{|i|i*3},*a]}

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

— मूल्य स्याही
स्रोत

बहुत बढ़िया! आउटपुट पहले tio पर गलत दिखता है, लेकिन ज़ूम आउट होने पर यह ठीक है।

— एरिक डुमिनील

10

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

f 0=[[1]]
f n=[x++map(*c)x++x|c<-[0,1,0],x<-f$n-1]

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

0 और 1 का ग्रिड बनाता है। रिक्त स्थान और एच के लिए एक चरित्र लंबे समय तक।

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

f 0=["H"]
f n=[x++map(min c)x++x|c<-" H ",x<-f$n-1]

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

— XNOR
स्रोत

9

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

381B«€s3Z€ẎF€µ¡

यह एक पूर्ण कार्यक्रम है जो 1 's और 0 ' s के 2 डी सरणी को प्रिंट करता है ।

इसे ऑनलाइन आज़माएं! या एच के रिक्त स्थान के साथ आउटपुट देखें ।

— डेनिस
स्रोत

9

APL (Dyalog Classic) , 14 बाइट्स

×/¨∘.≥⍨2|,⍳⎕⍴3

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

⎕ मूल्यांकित इनपुट n

,⍳⎕⍴3 0 1 2 से सभी n-tuples तत्वों के साथ

2| मॉड २

×/¨∘.≥⍨ टुपल्स ए और बी के प्रत्येक जोड़े की तुलना करके एक मैट्रिक्स बनाएं - यदि सभी तत्व बी के संबंधित तत्व हैं, तो यह 1 है, अन्यथा 0

— NGN
स्रोत

8

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

┌.{³2∙⁴┼+;3∙┼

यह कोशिश करो!

— dzaima
स्रोत

8

आर , 64 बाइट्स

function(n)Reduce(`%x%`,rep(list(matrix(c(1,1,1,0,1,0),3,3)),n))

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

लुइस मेन्डो के जवाब के एक बेशर्म बंदरगाह के रूप में, क्रोनकर उत्पाद द्वारा कम हो जाता है ।

पाद लेख परिणाम को अच्छी तरह से प्रिंट करता है, लेकिन यह एक गुमनाम फ़ंक्शन है जो अंतरिक्ष matrixके 1लिए Hऔर उसके 0लिए रिटर्न देता है।

— ग्यूसेप
स्रोत

8

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

n->{n+=Math.pow(3,n)-n;int s=1,H[][]=new int[n][n],x,y;for(;s<n;s*=3)for(x=n;x-->0;)for(y=n;y-->0;)H[x][y]|=~(x/s%3)&y/s%3&1;return H;}

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

एक रिटर्न int[][]के साथ 0के लिए Hऔर 1के लिए space। यह वास्तव Hमें "पाइलिंग" के बजाय 's' की एक दीवार को बनाता है H।

स्पष्टीकरण

n->{                        // An int to int[][] lambda function
  n+=Math.pow(3,n)-n;       //  change n to 3^n, through +=...-n to avoid an explicit cast
  int s=1,                  //  size of the carvings.
      H[][]=new int[n][n],  //  the 2D array to return, filled with 0s
      x,                    //  counter for the 2D array
      y;                    //  counter for the 2D array
  for(;s<n;s*=3)            //  for each size
    for(x=n;x-->0;)         //   for each row
      for(y=n;y-->0;)       //    for each column
        H[x][y] |=          //     assign 1 to a cell of the array if...
           ~(x/s%3)         //      it is located in the "holes" of the H
          &y/s%3            //
          &1;               //      
  return H;                 //  return the array
}                           // end the lambda

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

Math.pow

— Selim

4

@ बाइट की गिनती में स्थिर आयात की आवश्यकता है। तो मैं हार जाता ... 19 बाइट्स।

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

7

वी , 22 बाइट्स

éHÀñäLgvr PGï3PkyHGpH

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

Hexdump:

00000000: e948 c0f1 e416 4c67 7672 2050 47ef 3350  .H....Lgvr PG.3P
00000010: 6b79 4847 7048                           kyHGpH

यह मूल रूप से Sierpinski कालीन और अराजकता गोल्फ पर फ्रैक्टल प्लस के रूप में सटीक दृष्टिकोण है ।

— DJMcMayhem
स्रोत

क्या वह फ्रेंच है?

— स्टेन स्ट्रम

7

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

f=lambda r:-r*'H'or[x+[x,' '*3**r][b]+x for b in 1,0,1for x in f(r-1)]

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

फ़ंक्शन स्ट्रिंग्स की एक सूची आउटपुट करता है।

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

r=input()
for i in range(3**r):x,s=' H';exec"s+=[x,s][i%3%2]+s;x*=3;i/=3;"*r;print s

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

अन्य 3 * 3 भग्न पैटर्न के समान टेम्पलेट का उपयोग करता है:

— XNOR
स्रोत

6

जे , 25 22 बाइट्स

,./^:2@(*/#:@5 7 5)^:]

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

        */               multiply by
          #:@5 7 5       the binary matrix shaped like H
,./^:2                   assemble the 4-dimensional result into a matrix
                   ^:]   do it input times

— FrownyFrog
स्रोत

6

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

g#f=g<>f<>g
w=map.(id#)
(iterate(w(>>" ")#w id)["H"]!!)

यह केवल नवीनतम संस्करण के साथ काम करता है Prelude, क्योंकि यह निर्यात करता <>है Data.Semigroup। TIO पर इसे चलाने के लिए, जैसा कि यहाँ किया गया है, एक आयात जोड़ें: इसे ऑनलाइन आज़माएँ!

g#f=              -- function # takes two functions g and f and a list s
                  -- and returns
   g <> f <> g    -- g(s), followed by f(s) and another g(s)

w=                -- w takes a function and a list of lists
                  -- (both as unnamed parameters, because of pointfree style,
                  -- so let's call them f and l)
  map.(id#)       -- return map(id#f)l, i.e. apply (id#f) to every element of l

  w(>>" ")#w id   -- this partial application of # is a function that
                  -- takes the missing list (here a list of lists)
                  -- remember: (>>" ") is the function that replaces every element
                  -- of a list with a single space

iterate(   )["H"] -- starting with a singleton list of the string "H"
                  -- which itself is a singleton list of the char 'H'
                  -- repeatedly apply the above function
              !!  -- and pick the nth iteration



Example for ["H H", "HHH", "H H"], i.e.

   H H
   HHH
   H H

call the iterated function:
                    ( w(>>" ")         # w id       ) ["H H","HHH","H H"]

expand w:           ( map(id#(>>" "))  # map(id#id) ) ["H H","HHH","H H"]

expand outermost #: map(id#(>>" "))["H H","HHH","H H"] ++
                    map(id#id)     ["H H","HHH","H H"] ++
                    map(id#(>>" "))["H H","HHH","H H"]

expand map:         [(id#(>>" "))"H H",   (id#(>>" "))"HHH",   (id#(>>" "))"H H"] ++
                    [(id#id)     "H H",   (id#id)     "HHH",   (id#id)     "H H"] ++
                    [(id#(>>" "))"H H",   (id#(>>" "))"HHH",   (id#(>>" "))"H H"]

expand other #:     ["H H"++"   "++"H H", "HHH"++"   "++"HHH", "H H"++"   "++"H H"] ++
                    ["H H"++"H H"++"H H", "HHH"++"HHH"++"HHH", "H H"++"H H"++"H H"] ++
                    ["H H"++"   "++"H H", "HHH"++"   "++"HHH", "H H"++"   "++"H H"]

collaps ++:         ["H H   H H", "HHH   HHH", "H H   H H",
                     "H HH HH H", "HHHHHHHHH", "H HH HH H",
                     "H H   H H", "HHH   HHH", "H H   H H"]

which is printed line by line: 

  H H   H H
  HHH   HHH
  H H   H H
  H HH HH H
  HHHHHHHHH
  H HH HH H
  H H   H H
  HHH   HHH
  H H   H H

संपादित करें: -9 बाइट्स @ पोटैटो44 के लिए धन्यवाद।

— nimi
स्रोत

3

यदि आप जीएचसी 8.4 का उपयोग करते हैं तो आपको (#)नीचे गोल्फ करने में सक्षम होना चाहिए g#f=g<>f<>g। ऐसा इसलिए है क्योंकि Semigroupअब प्रस्तावना में है।

— आलू ४४

@ आलू 44: मुझे पूरा यकीन है कि यह बहुत सारी चुनौतियों में मदद करेगा। धन्यवाद!

— नमि

5

पर्ल 5 , 46 44 43 41 40 बाइट्स

1 आधारित गिनती। उपयोग 0और के 1लिए Hऔर अंतरिक्ष, एक अग्रणी 1(अंतरिक्ष) है

say//,map/$'/^1,@;for@;=glob"{A,.,A}"x<>

Mtve द्वारा एक क्लासिक विचार के आधार पर।

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

— टन हास्पेल
स्रोत

1

N for 3 के लिए आउटपुट काफी सही नहीं है।

— प्रिमो

@primo प्रोग्राम सही था लेकिन TIO स्पेशल कैरेक्टरों के UTF-8 संस्करण का उपयोग करता है। मैं बजाय भागने का उपयोग करने के लिए लिंक तय किया है, लेकिन कार्यक्रम अभी भी काम करता है अगर आप वास्तविक शाब्दिक वर्णों का उपयोग करते हैं

— टन Hharma

मुझे पता नहीं क्यों \321आवश्यक है, कोई भी चरित्र काम करने लगता है। //और $'भी बदल सकते हैं //gऔर $`, लेकिन मुझे यकीन नहीं है कि यह एक सुधार की ओर जाता है।

— प्रिमो

1

@primo धन्यवाद! मैं अभी भी पुराने mtve समाधान से प्राप्त कोड से काम कर रहा था, जहां \321का पूरक था .(एक अन्य फ्रैक्टल पैटर्न उत्पन्न करने के लिए)। लेकिन मैंने बिट-सप्लीमेंट को छोड़ दिया, इसलिए मुझे अब और ज़रूरत नहीं है। मैंने इस्तेमाल किया //gऔर $ `तो मैं आसानी से कमांडलाइन से कोड का परीक्षण कर सकता हूं ( //और $'मुझे एक लाभ नहीं मिल सकता है, प्राप्त बाइट एक स्थान या !फिर से बर्बाद हो जाती है)

— टन हास्पेल

5

विम - 66 56 54 बाइट्स

A @ c H esc " r d ^ q c { ctrl-v } " a y g v r space g v d " a P P " a P V G " b y P g v ctrl-v $ d " a P . . G " b p q @ r

इनपुट को बफर में एक संख्या के रूप में लिया जाता है।

— चायल दस ब्रिंक
स्रोत

मुझे क्या टाइप करना है, एक बैश प्रॉम्प्ट से शुरू, यह मानते हुए कि मैंने विम स्थापित किया है, परिणाम देखने के लिए?

— फाबिएन

Vim टाइप करें, एंटर दबाएँ, बफर में इनपुट नंबर (जैसे 3) टाइप करें, फिर सामान्य मोड से, पोस्ट से कीज़ के क्रम को दबाएँ।

— चायल दस ब्रिंक

वेनिला विम

— चील टेन ब्रिंक

कोड में एक टाइपो था। बस इसे ठीक कर दिया।

— चिले दस ब्रिंक

1

काम करता है! <kbd> I </ kbd> एक पूंजी है, जो ell नहीं है। :set nowrapपरिणाम देखने के लिए, 4 और अधिक के लिए।

— फाबिएन

4

एपीएल (डायलॉग यूनिकोड) , 38 34 बाइट्स ^{एसबीसीएस}

({(⍵,(0×⍵),⍵){⍺⍪⍵⍪⍺}⍵,⍵,⍵}⍣⎕)1 1⍴1

आउटपुट, 1एच का 0प्रतिनिधित्व करने और अंतरिक्ष का प्रतिनिधित्व करने के साथ एक 2-आयामी सरणी है।

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

— MJacquet
स्रोत

2

PPCG में आपका स्वागत है! आप छोड़ सकते हैं f←और 1 बाइट प्रत्येक के रूप में वर्ण गिनती: codegolf.meta.stackexchange.com/questions/9428/... यह भी से इनपुट लेने के लिए कानूनी माना जाता है ⎕, यानी की जगह ⍣⍵के साथ ⍣⎕और बाहरी DFN के ब्रेसिज़ छोड़ देते हैं।

— ngn

धन्यवाद! मैंने पहले कभी औपचारिक रूप से एपीएल को गोल्फ नहीं किया है, इसलिए इनकी मदद करनी चाहिए।

— MJacquet

1 1⍴1के रूप में लिखा जा सकता है ⍪1और फिर ऑपरेटर के आसपास के परिंदे अनावश्यक हो जाते हैं। यदि आप ट्रेनों से परिचित हैं - वे यहाँ बहुत मदद कर सकते हैं।

— ngn

इसके अलावा, ⍨आपका दोस्त है: (⍵,(0×⍵),⍵)=>(⍵,⍵,⍨0×⍵)

— ज़ाचारि

4

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

HＦＥＮＸ³ι«Ｊ⁰¦⁰Ｃ⁰ιＣιιＴ⊗ι⊗ι‖ＯＯ→↓ι

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

मूल प्रिंट करें H।

ＦＥＮＸ³ι«

size3 की पहली शक्तियों पर लूप ।

Ｊ⁰¦⁰

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

Ｃ⁰ι

एक डोमिनोज़ बनाते हुए पिछली पुनरावृति को नीचे की ओर कॉपी करें।

Ｃιι

Tetromino बनाकर, परिणाम को नीचे और दाएं कॉपी करें।

Ｔ⊗ι⊗ι

कैनवास को एक Lआकार के ट्रायमिनो के नीचे ट्रिम करें ।

‖ＯＯ→↓ι

ओवरलैप के साथ क्षैतिज और लंबवत रूप से कैनवास को प्रतिबिंबित करें, पुनरावृत्ति को पूरा करें।

चारकोल दूसरों की तुलना में कुछ भग्न में बेहतर है। यहाँ एक समान विचार है, लेकिन लगभग आधे आकार में:

HＦＮ«⟲Ｃ²⁶‖ＯＯLＸ³ι

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

— नील
स्रोत

4

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

def g(a,x,y,s):
	if s:s/=3;[g(a,x+k/3*s,y+k%3*s,s)for k in 0,2,3,4,5,6,8]
	else:a[x][y]=1
def f(s):s=3**s;a=eval("s*[0],"*s);g(a,0,0,s);print a

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

-30 बाइट्स पुनरावर्ती के लिए धन्यवाद

अच्छा स्वरूपण के लिए आवरण कोड है। यदि आप इसे हटाते हैं तो यह ठीक काम करता है

— HyperNeutrino
स्रोत

कुछ गोल्फ

— पुनरावर्ती

4

PHP 7, 125 109 बाइट्स

एक अलग दृष्टिकोण: परिणाम को घोंसले के शिकार और समतल करने के बजाय, यह सिर्फ पंक्तियों और स्तंभों के माध्यम से लूप करता है और प्रिंट करने के लिए Hया पता लगाने के लिए एक 3 लूप का उपयोग करता है _।

संपादित करें: पंक्ति / स्तंभ छोरों को एक में जोड़कर बहुत सहेजा गया, हालांकि आंतरिक लूप के लिए कमी को ठीक करने में थोड़ा सा समय लगा। पावर ऑपरेटर के लिए PHP 7 की आवश्यकता है।

उन्हें ऑनलाइन कोशिश करो !

for($z=3**$argn;$z*$z>$q=$p;print$c."
"[++$p%$z])for($c=H;$q;$q-=$q/$z%3*$z,$q/=3)if($q%3==1&&$q/$z%3-1)$c=_;

परिणाम प्रिंट करता है। साथ पाइप के रूप में चलाएँ -nR।

योग्य फ़ंक्शन, 147 130 बाइट्स

function r($n){for($z=3**$n;$z*$z>$q=$p;$r.=$c."
"[++$p%$z])for($c=H;$q;$q-=$q/$z%3*$z,$q/=3)if($q%3==1&&$q/$z%3-1)$c=_;return$r;}

एक भी स्ट्रिंग देता है। डिफ़ॉल्ट कॉन्फ़िगरेशन (नहीं php.ini) के साथ चलाएँ ।

— टाइटस
स्रोत

1

%3==1से बदला जा सकता है %3&1।

— प्रिमो

3

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

,’b3U×"3S_4A1e
3*çþ`ị⁾ HY

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

यद्यपि यह मौजूदा जेली प्रस्तुत करने की तुलना में लंबा है , यह समन्वय से बस प्रत्येक चरित्र को स्वतंत्र रूप से उत्पन्न करने की कोशिश करता है।

विशेष रूप से, अगर समन्वय है (x,y)(1-अनुक्रमण), पहली कड़ी रिटर्न 0और 1से मेल खाती है Hऔर क्रमशः।


,                Pair. Get (x,y)
 ’               Decrement. Get (x,y) (0-indexing)
  b3             Convert to base 3 digits.
    U            Upend. So next operations can pair the corresponding digits.
     ×"3         Multiply the first element (list) by 3.
        S        Sum (corresponding digit together). Let the sum be s.
         _4A1e   Check if any of abs(s-4) is 1. Equivalently, check
                 if there is any 3 or 5 in the list of s.

इसके अलावा, 5 बाइट्स ị⁾ HYको स्वरूपण के लिए उपयोग किया जाता है, इसलिए यह प्रोग्राम (20 बाइट्स) भी मान्य है (लेकिन आउटपुट अच्छा नहीं दिखता है):

,’b3U×"3S_4A1e
3*çþ`

— user202729
स्रोत

3

टी-एसक्यूएल , 267 261 बाइट्स

DECLARE @N INT=3DECLARE @ TABLE(I INT,H VARCHAR(MAX))INSERT @ VALUES(1,'H H'),(2,'HHH'),(3,'H H');WITH
T AS(SELECT 1 A,3 P,I J,H S FROM @ UNION ALL SELECT A+1,P*3,J*P+I,REPLACE(REPLACE(S,' ','   '),'H',H)FROM @,T
WHERE A<@N)SELECT S FROM T WHERE A=@N ORDER BY J

— रज़वान सोकोल
स्रोत

कोड गोल्फ पर यह मेरा पहला जवाब है, इसलिए अगर कोई गलती हुई तो कृपया मेरी मदद करें। साथ ही, मेरी पसंदीदा भाषा Transact-SQL है, जो शॉर्ट कोड के लिए बहुत उपयुक्त नहीं है।

— रज़वान सोकोल ११'१

1

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

— केयर्ड सिक्काहिंगाहिंग

मैंने एक sqlfiddle को जोड़ने की कोशिश की, लेकिन यह तालिका चर के साथ अच्छी तरह से काम नहीं करता है। अगर मैं सामान्य तालिकाओं का उपयोग करता हूं, तो यह 1 बाइट से भी छोटा है: sqlfiddle.com/# -18 / eb14e/2 । हालाँकि, आउटपुट को sqlfield द्वारा सही ढंग से स्वरूपित नहीं किया गया है, लेकिन यह SSMS में ठीक काम करता है।

— रज़वान सोकोल

1

आप कुछ अनावश्यक

— व्हाट्सएप

मुझे केवल 261 मिला। मुझे क्या याद आ रहा है?

— रज़वान सोकोल

2

PHP 7, 153 बाइट्स

    function p($n){$r=["H H",HHH,"H H"];if(--$n)foreach(p($n)as$s){$r[+$i]=$r[$i+6*$p=3**$n]=str_pad($s,2*$p).$s;$r[3*$p+$i++]=$s.$s.$s;}ksort($r);return$r;}

डिफ़ॉल्ट कॉन्फ़िगरेशन (नहीं php.ini) के साथ चलाएं या इसे ऑनलाइन आज़माएं ।

— टाइटस
स्रोत

2

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

//;$_ x=3,$.=s|.+|$&@{[$$_++/$.&1?$&:$"x$.]}$&|g for($_=H.$/)x$'

आवश्यकता है -p, इनपुट स्टड से लिया गया है। आउटपुट एस का एक एच है H।

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

— Primo
स्रोत

इस साइट पर गिनती बदल गई है, आपको -pअब और गिनने की ज़रूरत नहीं है (मुझे लगता है कि यह पर्ल के लिए बहुत उदार है, लेकिन यह अब ऐसा है)

— टन हास्पेल

2

PHP (5.6+), 94 बाइट्स

<?for(;$H>$e*=3or$e=($i+=$e&&print"$s
")<${$s=H}=3**$argn;)$s.=str_pad($i/$e%3&1?$s:'',$e).$s;

-Fकमांड लाइन विकल्प के साथ प्रयोग किया जाता है । दुभाषिया चूक मानते हैं ( -n)। पावर ऑपरेटर के कारण 5.6 से पहले के संस्करणों पर काम नहीं करेगा।

नमूना उपयोग

$ echo 3|php -nF h-carpet.php
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H HH HH HH HH HH HH HH HH H
HHHHHHHHHHHHHHHHHHHHHHHHHHH
H HH HH HH HH HH HH HH HH H
H H   H HH H   H HH H   H H
HHH   HHHHHH   HHHHHH   HHH
H H   H HH H   H HH H   H H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H
H HH HH H         H HH HH H
HHHHHHHHH         HHHHHHHHH
H HH HH H         H HH HH H
H H   H H         H H   H H
HHH   HHH         HHH   HHH
H H   H H         H H   H H

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

— Primo
स्रोत

1

आप एक बाइट बचा सकते हैं: के $s.$s.$sबजाय $s.=$s.$s। और आप <?के -Rबजाय के साथ की जरूरत नहीं है -F।

— टाइटस

बाइट के लिए धन्यवाद। के बारे में -R, क्या आप मुझे पूरा उपयोग दिखा सकते हैं?

— प्रिमो

बस की तरह है -nF: echo <input> | php -nR '<code>'। -rलगभग वही है php -nr '<code>' <arguments>:।

— टाइटस

शायद मैं इसे काम करने के लिए बहुत बेवकूफ हूँ: / i.stack.imgur.com/jqpmk.png

— primo

1

preg_filterनई रेखाओं को संरक्षित करते हुए प्रत्येक पंक्ति को पुनरावृत्त करना, लगभग बराबर join("\n",array_map(function(){...},split("\n",$s.$s.$s))), लेकिन काफी कम क्रिया है। मैं शुरू में str_padबदल गया था , sprintfक्योंकि यह एक बाइट से छोटा था:'"\0".str_pad($$i++/$i&1?"\0":"",$i)."\0"'

— प्राइमो

1

CJam - 103 97 87 76 बाइट्स

{H{ae_,S*}%}:Il~a:A];{A_W={)(a9*+:A;[[HIH][HHH][HIH]]{z~}%}{);:A;"H"}?}:H~N*

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

ऑनलाइन कोशिश करें

— चायल दस ब्रिंक
स्रोत

1

के (ngn / k) , 18 बाइट्स

{~|/a<\:'a:1=!x#3}

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

— NGN
स्रोत

1

जाप , 23 बाइट्स

_·£[X³XX³]Ãy c ·û}gQq)y

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

अनपैक्ड और यह कैसे काम करता है

Z{ZqR mXYZ{[Xp3 XXp3]} y c qR û}gQq)y

Z{    Declare a function that accepts a string...
  ZqR   Split by newline...
  mXYZ{   and map each row into...
    [Xp3 XXp3]  an array of [X.repeat(3), X, X.repeat(3)]
  }
  y   Transpose the resulting 2D array
  c   Flatten
  qR  Join with newline
  û   Center-pad each row to the longest
}
gQq)  Apply the above function to '"' recursively
y     Transpose the resulting 2D string

ट्रांसपोंड पैटर्न का उपयोग करना

III
 I 
III

मूल Hपैटर्न की तुलना में कहीं अधिक आसान है , कम से कम जाप में जहां Iस्ट्रिंग रिपीट और सेंटर-पेडिंग के साथ किया जा सकता है।

— bubbler
स्रोत

0

सी ++ 11 - 138 बाइट्स

सुनिश्चित नहीं है कि इस उत्तर में एक वैध वाक्यविन्यास है या नहीं।

#define A a?1:0
template<int N>struct H{H<N-1>h[9];H(int a):h{A,0,A,A,A,A,A,0,A}{}};template<>struct H<0>{char h;H(int a):h{a?'H':' '}{}};

वर्किंग कोड के साथ अनगुल्ड

#include <iostream>

#define A a?1:0

template<int N>
struct H
{
  H<N-1> h[9];

  H(int a) : h{A,0,A,A,A,A,A,0,A}
  {}
};

template<>
struct H<0>
{
  char h;

  H(int a) : h{a?'H':' '}
  {}
};

int pow(int a, int b)
{
  int res=1;

  for (int i=1; i<=b; ++i)
    res *= a;

  return res;
}

template<int N>
char getHvalue(int i, int j, H<N> &hn)
{
  int n3=pow(3, N-1);

//std::cout << N << " " << i << " " << j << std::endl;

  return getHvalue(i%n3, j%n3, hn.h[i/n3*3+j/n3]);
}

template<>
char getHvalue<0>(int, int, H<0> &hn)
{
  return hn.h;
}

int main()
{
  H<0> h0(1);

  std::cout << getHvalue(0, 0, h0) << std::endl;

  std::cout << "\n====================\n" << std::endl;

  H<1> h1(1);

  for (int i=0; i<3; ++i) {
    for (int j=0; j<3; ++j)
      std::cout << getHvalue(i, j, h1);
    std::cout << std::endl;
  }

  std::cout << "\n====================\n" << std::endl;

  H<2> h2(1);

  for (int i=0; i<9; ++i) {
    for (int j=0; j<9; ++j)
      std::cout << getHvalue(i, j, h2);
    std::cout << std::endl;
  }

  std::cout << "\n====================\n" << std::endl;

  H<3> h3(1);

  for (int i=0; i<27; ++i) {
    for (int j=0; j<27; ++j)
      std::cout << getHvalue(i, j, h3);
    std::cout << std::endl;
  }

  return 0;
}

— Tsathoggua
स्रोत

छोटे "एच" से एक "एच" बनाएँ

चुनौती

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

वोल्फ्राम भाषा (गणितज्ञ) , 46 बाइट्स

कैनवस , 14 12 बाइट्स

MATL , 12 11 बाइट्स

व्याख्या

स्टैक्स , 16 15 बाइट्स

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

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

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

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

APL (Dyalog Classic) , 14 बाइट्स

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

आर , 64 बाइट्स

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

स्पष्टीकरण

वी , 22 बाइट्स

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

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

जे , 25 22 बाइट्स

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

पर्ल 5 , 46 44 43 41 40 बाइट्स

विम - 66 56 54 बाइट्स

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

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

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

PHP 7, 125 109 बाइट्स

योग्य फ़ंक्शन, 147 130 बाइट्स

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

टी-एसक्यूएल , 267 261 बाइट्स

PHP 7, 153 बाइट्स

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

PHP (5.6+), 94 बाइट्स

CJam - 103 97 87 76 बाइट्स

के (ngn / k) , 18 बाइट्स

जाप , 23 बाइट्स

अनपैक्ड और यह कैसे काम करता है

सी ++ 11 - 138 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 38 34 बाइट्स ^{एसबीसीएस}