उद्यान वास्तुकला - ASCII शैली

Question

हमारे घर के बाहर एक वर्ग 10x10 मीटर का बगीचा है। हम घास लगाना और एक छत बनाना चाहते हैं। हमने तय किया है कि बगीचे को कैसे विभाजित किया जाए, लेकिन हमने घास बनाम छत की मात्रा के बीच का अनुपात तय नहीं किया है।

हमें इसकी कल्पना करने में सहायता की आवश्यकता है, और ASCII- कला स्पष्ट रूप से ऐसा करने का सबसे अच्छा तरीका है।

---

चुनौती:

समावेशी श्रेणी में एक पूर्णांक लें [0, 100] (या वैकल्पिक रूप से दशमलव [0, 1]) जिसमें यह दर्शाया गया है कि कितने प्रतिशत बगीचे की छत होनी चाहिए।

छत के एक वर्ग मीटर का प्रतिनिधित्व या तो डैश -या बार द्वारा किया जाएगा |। घास के एक वर्ग मीटर को हैश मार्क द्वारा दर्शाया जाएगा #।

• यदि छत की मात्रा 50% से कम या उसके बराबर है, तो बगीचे को सलाखों के साथ कवर किया जाना चाहिए, नीचे बाएं कोने में शुरू करना, और लंबवत भरना, फिर क्षैतिज रूप से।
• यदि छत की मात्रा 50% से अधिक है, तो हम चाहते हैं कि अलंकार दूसरे तरीके (सलाखों के बजाय डैश) हो, और निचले बाएं कोने में शुरू हो, और क्षैतिज रूप से भरें, फिर लंबवत।

उदाहरण:

N = 25%
||########
||########
||########
||########
||########
|||#######
|||#######
|||#######
|||#######
|||#######

N = 75%
##########
##########
-----#####
----------
----------
----------
----------
----------
----------
----------

N = 47%
||||######
||||######
||||######
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####

N = 50%
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####
|||||#####

N = 51%
##########
##########
##########
##########
-#########
----------
----------
----------
----------
----------

N = 0%
##########
##########
##########
##########
##########
##########
##########
##########
##########
##########

N = 100%
----------
----------
----------
----------
----------
----------
----------
----------
----------
----------

यह कोड-गोल्फ है इसलिए बाइट्स जीतने वाला सबसे छोटा कोड है। I / O के संबंध में मानक नियम। यह एएससीआईआई-कला है, इसलिए आउटपुट को ऊपर दिए गए उदाहरणों की तरह दिखना चाहिए। यानी आउटपुट ["|", "|" ...]ठीक नहीं है।

स्पष्टीकरण हमेशा की तरह प्रोत्साहित किया जाता है :)

Comments

मेरी पहली धारणा यह थी कि दो मामलों का मतलब सिर्फ दो अलग-अलग गोल्फिंग कार्यों को हल करना होगा, लेकिन इसमें पाया जाने वाला सामान्य ढांचा है जो इसे उनके साथ साझा करने के लायक बनाता है।

— xnor

Answer 1

APL (Dyalog) , 34 बाइट्स

अनाम उपसर्ग फ़ंक्शन 0–100 की सीमा में पूर्णांक की अपेक्षा करता है। मान लिया गया है ⎕IO( मैं ndex हे rigin) होने के लिए 0है, जो कई सिस्टम पर डिफ़ॉल्ट है।

{'#-|'[⊖⍉⍣s⊢10 10⍴100↑⍵⍴1+s←50≥⍵]}

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

{… } लंबोदर; ⍵तर्क है:

 '#-|[… ] निम्न सरणी के साथ स्ट्रिंग को अनुक्रमित करें:

 50≥⍵ 1 यदि 50 तर्क से अधिक या बराबर है, तो 0

 s← रों में दुकान (के लिए रों मॉल)

 1+ वेतन वृद्धि

 ⍵⍴तर्क-लंबाई के लिए  चक्रीय रूप से r eshape

 100↑ उस के पहले सौ, शून्य के साथ गद्दी ले लो

 10 10⍴ r दस पंक्तियों और दस स्तंभों तक पहुंचें

 ⊢ कि (अलग उपज sसे 10 10)

 ⍉⍣s यदि छोटा है तो संक्रमण करें

 ⊖ उलटा पलटना

Comments

{{# - | ’[⊖ (# + ⍣) ⍵≤ ()50) ⊢⍵> ⍨⎕।, ⍎¨∘d]}

— ngn

बहुत मेरे दृष्टिकोण के करीब:{⊖⍉⍣c⊢10 10⍴(⍵/'-|'⊃⍨c←⍵≤50),100/'#'}

— एरिक Outgolfer

@EriktheOutgolfer आपको केवल आवश्यकता है99/'#'

— ngn

@ ऑन्ग ओह राइट,⍴

— एरिक द आउटग्राफर

@ng यह बिलकुल अलग है। आप इसे पोस्ट क्यों नहीं करते?

— 19

Answer 2

जे , 39, 38 37 बाइट्स

[:|.>&50|:'#-|'"0{~_10]\100{.]$1+51>]

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

                     _10]\100{.]$1+51>] - prepares a 10x10 array of 0, 1 or 2
                                 1+51>] - 1 if N<=50 otherwise 2
                               ]$       - list of N copies of the above (1 or 2)
                          100{.         - the above list filled to 100 items with 0
                     _10]\              - reshape the list to a 10x10 array
           '#-|'"0                      - constant array of chars
                   {~                   - replaces each digit 0, 1 or 2 with #, - or |     
     >&50                               - is N>50 ? 
         |:                             - if not, transpose the array
                                          (in fact |: here is rearrange axes
                                           0 - transpose
                                           1 - leave it intact)        
 |.@                                    - reverse the order ot the rows

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

Comments

{.सीमा तर्क के साथ एक अच्छी चाल है।

— योना

31 बाइट्स:(]|.@|:_10{&'#|-'\100{.1+$)>&50

— फ्राईफ्रॉग

@ FrownyFrog - महान कोड!

— गैलेन इवानोव

@ जोना - हां, यह कभी-कभी बहुत काम आता है। मैंने भी कोशिश की, _100{. जो शुरुआत में भरता है, लेकिन फिर मुझे प्रत्येक पंक्ति को उलटने की जरूरत थी, इसलिए मैंने इसे छोड़ दिया।

— गैलेन इवानोव

Answer 3

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

[0 ... 100] में पूर्णांक के रूप में इनपुट लेता है ।

n=>(y=9,g=x=>~y?'|-#'[[x,y][k=n/51|0]*9+x+y<n?k:2]+[`
`[x-9]]+g(x++-9?x:!y--):'')(0)

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

let f =

n=>(y=9,g=x=>~y?'|-#'[[x,y][k=n/51|0]*9+x+y<n?k:2]+[`
`[x-9]]+g(x++-9?x:!y--):'')(0)

;[25, 75, 47, 50, 51, 0, 100]
.forEach(n => O.innerText += n + '%:\n' + f(n) + '\n')

<pre id=O></pre>

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

n => (                          // given the terrace percentage n
  y = 9,                        // and starting with y = 9
  g = x =>                      // g = recursive function taking x:
    ~y ?                        //   if y is greater than or equal to 0:
      '|-#'[                    //     pick the relevant character:
        [x, y][k = n / 51 | 0]  //       using k = 1 if n > 50, 0 otherwise
        * 9 + x + y             //       and comparing either 10 * x + y or 10 * y + x
        < n ?                   //       with n; if we're located over the terrace area:
          k                     //         append either '|' or '-'
        :                       //       else:
          2                     //         append '#'
      ] +                       //     end of character insertion
      [`\n`[x - 9]] +           //     append a linefeed if x == 9
      g(x++ - 9 ? x : !y--)     //     update (x, y) and do a recursive call
    :                           //   else:
      ''                        //     stop recursion
)(0)                            // initial call to g with x = 0

Answer 4

पायथन 2 , 121 117 116 बाइट्स

def f(n):
 s=[('-|'[n<51]*n+'#'*100)[i*10:][:10]for i in range(10)]
 for l in[s,zip(*s)][n<51][::-1]:print''.join(l)

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

Comments

मुझे लगता है कि [i*10:-~i*10]हो सकता है [i*10:][:10]।

— जोनाथन फ्रेच

@JonathanFrech धन्यवाद :)

— टीएफ

Answer 5

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

<©51ị⁾|-ẋḷ"”#ẋ³¤s⁵Z®¡ṚY

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

Çइनपुट बदलने के लिए पाद में पहले संख्या बदलें । कमांड-लाइन तर्कों के बिना एक कार्यक्रम में एक मोनोएडिक लिंक के रूप में काम करता है, जिसकी अनुमति है ।

Comments

बहुत अच्छा जवाब +1। 23 बाइट्स एक मोनडिक लिंक के रूप में ( ȷ2-> ³)

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

मैं 24 बाइट्स भी हासिल करने में कामयाब रहा , सोचा कि यह यहां भी प्रेरणा का स्रोत हो सकता है।

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

@ Mr.Xcoder मैंने ऐसा सोचा था, लेकिन मुझे वास्तव में यकीन नहीं है कि अगर मैं इस तरह की बात मान सकता हूं (केवल निलेडिक कार्यक्रमों में काम करेगा? हम्म ...)

— द आउटगॉल्फ

इस चर्चा को देखें मैं डेनिस के साथ था।

— श्री Xcoder

Answer 6

एसडब्ल्यूआई प्रोलॉग, 249 बाइट्स

p(X):-write(X).
r(X,Y,G):-G=<50,10*X-Y+1=<G,p('|').
r(_,_,G):-G=<50,p('#').
r(X,Y,G):-(10-Y)*10+X>G,p('#').
r(_,_,_):-p('-').
l(_,11,_):-nl.
l(X,Y,G):-r(Y,X,G),Z is Y+1,l(X,Z,G).
a(10,G):-l(10,1,G).
a(Y,G):-l(Y,1,G),Z is Y+1,a(Z,G).
s(G):-a(1,G),!.

समाधान बहुत सीधा है। प्रक्रिया aपंक्तियों का निर्माण करती है, lएक पंक्ति में स्तंभों को वर्ण लिखती है और यह rतय करती है कि किस वर्ण को मुद्रित किया जाना चाहिए।

Comments

G<51के बजाय काम करना चाहिए G<=50।

— लकोनी

Answer 7

MATL , 26 बाइट्स

'|-#'100:i>~o10eG50>?!E]P)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

'|-#'     % Push this string
100:      % Push array [1 2 ... 100]
i         % Input a number and push it
>~        % Less than or equal (element-wise)? This transforms the
          % array into [true ... true false ... false]
o         % Convert to double. True becomes 1, false becomes 0
10e       % Rehaspe into 10-row matrix, in column-major order
G         % Push input
50>       % Greater than 50?
?         % If so
  !       %   Transpose
  E       %   Multiply by 2 (element-wise). So 0 remains as 0, and
          %   1 becomes 2
]         % End
P         % Flip vertically
)         % Index into string, modularly. So 1 corresponds to '|',
          % 2 to '-', and 0 to '#'
          % Implicitly display

Answer 8

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

T=j=10
n=input()+T
while j:print([(n-j)/T*'|',min(n-T*j,T)*'-'][n>60]+'#'*T)[:T];j-=1

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

दोनों मामलों में प्रत्येक पंक्ति को #10 की लंबाई तक दाईं ओर रखा जाता है, जिससे हम दोनों मामलों के बीच उस कोड को साझा कर सकते हैं। संख्या 10 का उपयोग अक्सर पर्याप्त होता था कि अलियासिंग T=10ने सभ्य संख्या में बाइट्स को बचाया।

Comments

अमान्य! इनपुट से 51और उसके बाद, यह एक पंक्ति को याद करता है।

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

@EriktheOutgolfer वे किनारे मामले।

— 18

@EriktheOutgolfer धन्यवाद, मुझे लगता है कि यह इसे ठीक करता है?

— 18

लगता है, यह तय हो गया है।

— आउटगोल्फ

Answer 9

रूबी , 92 82 बाइट्स

->n{puts (r=0..9).map{|y|r.map{|x|n>(n>50?100-y*10+x:x*10+9-y)?"|-"[n/51]:?#}*''}}

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

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

ग्रिड के प्रत्येक सेल में नीचे बाएं कोने से शुरू होने वाली एक प्रगतिशील संख्या है और n के मान के आधार पर क्षैतिज या लंबवत रूप से आगे बढ़ती है:

यदि n>50, संख्या 100-y*10+xअन्यथा हैx*10+9-y

Answer 10

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

ＮθＧTχ#↶Ｆ÷θχ⟦χ⟧﹪θχ¿›θ⁵⁰‖Ｔ↖

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

Ｎθ                          Input integer into q
  Ｇ                         Draw filled polygon
   T                        Directions Right, Down, Left
    χ                       Size 10
     #                      Filled with `#`
      ↶                     Rotate cursor left (now points up)
       Ｆ÷θχ                 Repeat q/10 times (integer divide)
           ⟦χ⟧              Print 10 `|`s and move to the next column
              ﹪θχ           Print (q mod 10) `|`s
                 ¿›θ⁵⁰      If q > 50
                      ‖Ｔ↖   Reflect diagonally

Comments

@StewieGriffin ओह, गलत विकर्ण। जाँच नहीं करने के लिए क्षमा करें।

— नील

यह वास्तव में 25 अक्षर है , लेकिन 61 बाइट्स , है ना?

— जीरो ओने

@ZeroOne चारकोल अपने स्वयं के कोड पृष्ठ का उपयोग करता है ।

— नील

ओह मैं समझा! स्पष्टीकरण के लिए धन्यवाद। :)

— ज़ीरो

Answer 11

हस्क , 24 बाइट्स

↔?T†▼'-≤50⁰S↑C10+R⁰'|∞'#

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

व्याख्या

↔?T†▼'-≤50⁰S↑C10+R⁰'|∞'#  Input is a number, say n=12
                     ∞'#  Infinite string of #s: "#######...
                +         Prepend to it
                   '|     the character |
                 R⁰       repeated n times: "||||||||||||####...
             C10          Cut to pieces of length 10: ["||||||||||","||##########","##..
           S↑             Take first 10 pieces.
 ?     ≤50⁰               If n is at most 50,
  T                       then transpose,
   †▼'-                   else take minimum with '-' for each character.
↔                         Reverse, implicitly print separated by newlines.

Answer 12

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

┐* #M*+Mm√H.M»>?H§┐┌ŗ

यह कोशिश करो!

स्पष्टीकरण:

┐*                     push a vertical bar repeated input times
   #M*                 push "#" repeated 100 times
      +                add the two together
       Mm              mold to a length of 100
         √             convert to a square
          H            rotate clockwise
           .M»>?       if the input is greater than 50
                H        rotate the array clockwise again
                 §       reverse it horizontally
                  ┐┌ŗ    replace "|" with "-"

Answer 13

डीसी , ₂₁₀ 197 बाइट्स

[256r^1-255/]sx?dddI/dsT9r-sYI%ddIr-sqdsesm-I/sN[[lNlxx124*PIlN-lxx35*PIPlq1-dsq0<o]dsoxlN1+sNledsq0<oq]sJ50!<J[Ilxx35*PIPlY1-dsY0<E]sElY0<E[lmlxx45*PIlm-lxx35*PIP]sClTI>C[Ilxx45*PIPlT1-dsT0<Z]dsZx

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

Answer 14

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

f←{'#-|'[⊖(⍉+⍨)⍣(⍵≤50)⊢⍵>⍎¨∘.,⍨⎕d]}

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

Adám के जवाब पर आधारित है

⎕d स्ट्रिंग है '0123456789'

∘., कार्तीय गुणन

⍨ खुद के साथ

⍎¨ प्रत्येक का मूल्यांकन करें - 0..99 का 10x10 मैट्रिक्स प्राप्त करें

⍵>बूलियन मैट्रिक्स जहां तर्क ⍵अधिक है

⊢ विभाजक के रूप में कार्य करता है

(⍉+⍨)⍣(⍵≤50)यदि trans50 मैट्रिक्स को दोगुना ( +स्वयं के साथ) और स्थानांतरित करें ( ⍉)

⊖ ऊर्ध्वाधर उल्टा

'#-|'[ ]'#-|'मैट्रिक्स के प्रत्येक तत्व के साथ स्ट्रिंग को अनुक्रमित करें

Comments

यह व्याख्या उत्कृष्ट है, इम्हो।

— आदम

Answer 15

क्ष , ५१ बाइट्स

{-1@'reverse$[i;::;flip]10 10#@[100#"#";til x;:;"|-"i:x>50];}

Answer 16

रेटिना , 72 62 बाइट्स

.+
$*|
T`|`-`.{51,}
$
100$*#
M!10`.{10}
O$s`(?<!-.*)\S
$.%`
O`

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। संपादित करें: @MartinEnder की कुछ मदद से 10 बाइट्स सहेजे गए। स्पष्टीकरण:

.+
$*|

|दिए गए समय की संख्या को दोहराएं

T`|`-`.{51,}

लेकिन अगर इनपुट कम से कम 51 था, तो उन्हें -एस में बदल दें ।

$
100$*#

100 #एस लागू करें।

M!10`.{10}

10 के 10 समूहों में विभाजित करें, कुछ भी छोड़ दिया गया।

O$s`(?<!-.*)\S
$.%`

यदि इनपुट कम से कम 51 था, तो परिणाम को स्थानांतरित करें।

O`

परिणाम को क्रमबद्ध करें।

वैकल्पिक समाधान, 62 बाइट्स:

.+
$*|
T`|`-`.{51,}
$
100$*#
M!10`.{10}
O`
O$^s`\S(?!.*-)
$.%`

ट्रांसपोज़ करने से पहले छँटाई करने से ट्रांसपोज़िशन के लिए बाइट की बचत होती है लेकिन सही क्रम में परिणाम प्राप्त करने के लिए बाइट खर्च होती है।

Comments

आपको #पहले Oचरण की आवश्यकता नहीं है , क्योंकि $.%`अधिकांश पर होगा 9। आप किसी बाइट को अंत में किसी अन्य प्रकार के चरण की लागत पर लूप से बचाकर भी बचा सकते हैं, जैसे: tio.run/##K0otycxL/…M अंतिम चरण में उस चरण के परिणाम को फिर से व्यवस्थित करने का एक छोटा तरीका भी है ।

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

आह, उदाहरण के लिए, आप Oचरण के ठीक बाद सादे चरण को स्थानांतरित कर सकते हैं M, ताकि आप एक लुकबाइंड के बजाय एक लुकहेड का उपयोग कर सकते हैं।

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

@MartinEnder आपके संकेत के लिए धन्यवाद; मैं कुछ और बाइट्स बंद करने में सक्षम था।

— नील

Answer 17

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

n=input();x=n>50;k=x*81+10
while k>0:s='';exec"s+='|-##'[x::2][n<k];k+=x or 10;"*10;print s;k+=x*81-101

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

Answer 18

PHP, 119 + 1 बाइट्स

$r=str_pad("",100,"#");for($x=50<$n=$argn;$n--;)$r[90+($x?$n%10*2-$n:$n/10-$n%10*10)]="|-"[$x];echo chunk_split($r,10);

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

Answer 19

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

³<51
ȷ2Ḷ<s⁵ZḤ$Ç¡Ṛị“-|#”Y

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

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

मैं बहुत सारे सुपरस्क्रिप्ट का उपयोग करता हूं ...

³<51 ~ Helper link.

³    ~ The input.
 <   ~ Is smaller than
  51 ~ 51?
     ~ Yields 1 for truthy, 0 for falsy.

ȷ2Ḷ<s⁵ZḤ$Ç¡Ṛị“-|#”Y ~ Main link.

ȷ2                  ~ 1e2 (i.e compressed 100).
  Ḷ                 ~ Lowered range. Yields [0, 100) ∩ ℤ.
   <                ~ Is smaller than the input? (element-wise).
    s⁵              ~ Split into sublists of length 10.
         Ç¡         ~ Repeat <last link as a monad> times (either 1 or 0 times).
      ZḤ$           ~ Zip (transpose) and unhalve element-wise.
           Ṛ        ~ Reverse.
            ị       ~ Modular, 1-based indexing into...
             “-|#”  ~ The literal string "-|#".
                  Y ~ Join by newlines.

Answer 20

आर , 102 बाइट्स

n=scan();m=matrix("#",y<-10,y);m[0:n]="if"(n<51,"|","-");write("if"(n>50,m[,y:1],t(m[y:1,])),"",y,,"")

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

पुस्तकें n से है और बगीचे को स्टडआउट में प्रिंट करता है।

स्पष्टीकरण:

n=scan()               # read from stdin
m=matrix("#",10,10)               # create 10x10 matrix of "#"
m[0:n]="if"(n<51,"|","-")         # set the first n entries in m to the appropriate character
m="if"(n>50,                      # prepare for printing using write
       m[,10:1],                  # reverse m left to right
       t(m[10:1,]))               # flip m top to bottom and transpose
write(m,"",10,,"")                # write m to stdout in 10 columns with no separator