कार्ड का घर (संस्करण 1)

Question

संस्करण 2 यहाँ ।

सरल चुनौती: पूर्णांक दिया जाता है, दी गई कहानियों की संख्या के साथ कार्ड का एक घर बनाएं। यदि संख्या नकारात्मक है, तो घर को उल्टा-पुल्टा करें। उदाहरण:

Input: 2
Output:

 /\
 --
/\/\

Input: 5
Output:

    /\
    --
   /\/\
   ----
  /\/\/\
  ------
 /\/\/\/\
 --------
/\/\/\/\/\

Input: 0
Output: <empty, whitespace or newline>

Input: -3
Output:

\/\/\/
 ----
 \/\/
  --
  \/

इनपुट संख्यात्मक या एक स्ट्रिंग हो सकता है। आउटपुट बिल्कुल वैसा ही होना चाहिए जैसा कि अग्रणी और / या अनुगामी रिक्त स्थान और नए लिंक की अनुमति है।

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

Comments

यह सैंडबॉक्स से आता है ।

— चार्ली

क्या प्रमुख नए समाचारों की अनुमति है?

— झबरा

@ शैगी हाँ, आप भी व्हाट्सएप और नई सुर्खियाँ बना सकते हैं, जब तक आप कार्ड का घर दिखाते हैं, जैसा कि दिखाया गया है। मुझे कोई आपत्ति नहीं है अगर यह स्क्रीन के बाईं ओर संरेखित नहीं है।

— चार्ली

हम फेंक सकते हैं और त्रुटि पर input=0?

— रॉड

@ अगर यह खाली उत्पादन पैदा करता है तो इसे डिफ़ॉल्ट रूप से अनुमति दी जाती है

— लुइस मेंडो

Answer 1

पायथन 2 , 97 95 94 92 बाइट्स

^{-2 बाइट्स लुका की बदौलत
यह संस्करण एक अपवाद पैदा करता है n=0, लेकिन कुछ भी छापे बिना}

n=input()*2
m=abs(n)
for i in range(2,m+1)[::n/m]:print(i/2*'/-\-'[i%2::2][::n/m]).center(m)

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

गैर-त्रुटि संस्करण, पायथन 2, 94 बाइट्स

n=input()*2
x=n>0 or-1
for i in range(2,x*n+1)[::x]:print(i/2*'/-\-'[i%2::2][::x]).center(n*x)

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

Comments

x=n>0 or-1=>x=n>0or-1

— जकार्ही

@ Zacharý काम नहीं करता है, 0orएक ऑक्टा नंबर के रूप में व्याख्या की जाएगी

— रॉड

2 और बाइट्स काटें m=abs(n):। फिर, के बजाय xडाल n/m, के बजाय x*nडालm

— लूका

Answer 2

05AB1E , 30 29 24 बाइट्स

ÄF„--Nׄ/\N>×}).C∊2ä¹0‹è

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

व्याख्या

ÄF                         # for N in [0 ... abs(input-1)] do:
  „--N×                    # push the string "--" repeated N times
       „/\N>×              # push the string "/\" repeated N+1 times
             }             # end loop
              )            # wrap stack in a list
               .C          # pad strings on both sides to equal length
                 ∊         # vertically mirror the resulting string
                  2ä       # split in 2 parts
                    ¹0‹    # push input < 0
                       è   # index into the the list with the result of the comparison

Answer 3

PHP , 125 बाइट्स

इनपुट नेगेटिव लीडिंग न्यूलाइन

इनपुट पॉजिटिव ट्रेलिंग न्यूलाइन

for($s=str_pad;++$i<$b=2*abs($argn);)$t.=$s($s("",2*ceil($i/2),["-","/\\"][1&$i]),$b," ",2)."
";echo$argn>0?$t:$t=strrev($t);

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

PHP , 130 बाइट्स

for(;++$i<$b=2*abs($a=$argn);)echo($s=str_pad)($s("",2*abs(($a<0?$a:$i&1)+($i/2^0)),["-",["/\\","\/"][0>$a]][1&$i]),$b," ",2)."
";

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

Answer 4

MATL , 39 बाइट्स

|:"G|@-:~'/\'G0<?P]@E:)htg45*c]xXhG0<?P

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

व्याख्या

|         % Implicitly input, N. Absolute value
:"        % For k from 1 to that
  G|      %   Push absolute value of N again
  @-      %   Subtract k
  :       %   Range [1 2 ... N-k]
  ~       %   Convert to vector of N-k zeros
  '/\'    %   Push this string
  G0<     %   Is input negative?
  ?       %   If so
    P     %     Reverse that string (gives '\/')
  ]       %   End
  @E      %   Push 2*k
  :       %   Range [1 2 ... 2*k]
  )       %   Index (modularly) into the string: gives '/\/\...' or '\/\/...'
  h       %   Horizontally concatenate the vector of zeros and the string. Zeros
          %   are implicitly converted to char, and will be shown as spaces
  t       %   Duplicate
  g       %   Convert to logical: zeros remain as 0, nonzeros become 1
  45*c    %   Multiply by 45 (ASCII for '=') and convert to char
]         % End
x         % Delete (unwanted last string containing '=')
Xh        % Concatenate into a cell array
G0<       % Is input negative?
?         % If so
  P       %   Reverse that cell array
          % Implicit end. Implicit display

Comments

यार, वो तेज़ था !! मुझे आशा है कि संस्करण 2 इतना आसान नहीं होगा ... :-)

— चार्ली

Answer 5

सी (जीसीसी) , 169171 173 160 164 बाइट्स

#define F(A,B,C)for(i=A;B--;)printf(C);
#define P puts("");F(y,i," ")F(abs(n)-y
s,i,x,y;f(n){x=n<0;for(s=x?1-n:n;s--;){y=x?-n-s:s;P,i,x?"\\/":"/\\")y+=x;P,s>x&&i,"--")}}

नकारात्मक मामले बग के लिए +13 बाइट्स।

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

Ungolfed (207 रिक्त स्थान और नई पंक्ति को हटाने के बाद):

s, i, x, y;
f(n) {
  x = n < 0;
  for (s = x ? 1 - n : n; s--;) {
    y = x ? - n - s : s;
    puts("");
    for (i = y; i--;) printf(" ");
    for (i = abs(n) - y; i--;) printf(x ? "\\/" : "/\\");;
    y += x;
    puts("");
    for (i = y; i--;) printf(" ");
    for (i = abs(n) - y; s > x && i--;) printf("--");;
  }
}

Comments

@officialaimm तय! धन्यवाद

— Keyu गण

Answer 6

चारकोल, 31 28 27 बाइट्स

ＦＩ⊟⪪θ-«←ι↓→/…\/ι↙»‖Ｍ¿‹Ｎ⁰‖Ｔ↓

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मेरे पास लगभग 4 अलग-अलग 32 बाइट के उत्तर थे और फिर यह पाया गया। संपादित करें: उपयोग किए गए स्ट्रिंग हेरफेर करके 3 4 बाइट्स सहेजे गए abs। स्पष्टीकरण:

   ⪪θ-                          Split the input (θ = first input) on -
  ⊟                             Take the (last) element
 Ｉ                              Convert it to a number i.e. abs(θ)
Ｆ     «                         Repeat that many times
       ←ι                       Print half of the -s
         ↓                      Position for the /\s
          →/                    Print the first /
            …\/ι                Print half of any remaining \/s
                ↙               Position for the next row of -s
                 »              End of the loop
                  ‖Ｍ            Mirror everything horizontally
                    ¿‹Ｎ⁰        If the input was negative
                        ‖Ｔ↓     Reflect everything vertically

Comments

मुझे पता था कि एक चारकोल जवाब के साथ समाप्त होगा ¿‹θ⁰‖Ｔ↓। :-)

— चार्ली

जब चारकोल 05AB1E से ASCII- कला चुनौती पर O_o द्वारा पीटा जाता है

— Gryphon -

@ ग्रीफॉन मेरे पास एक बाइट नहीं है abs...

— नील

यह सच है, हालांकि यह देखना अजीब है। आपको आश्चर्य होता है कि दुनिया में क्या आ रहा है।

— ग्रीफॉन -

हाँ, यह एब्स बिलिन के साथ 23 बाइट होगा। (48K पर बधाई, btw)

— ETHproductions

Answer 7

जाप , 40 38 बाइट्स

-2 बाइट्स @ शुग्गी को धन्यवाद

o½½@aXc)ç +"--/\\\\/"ò gYv *Ug)pXc a÷

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

व्याख्या

o½½@aXc)ç +"--/\\\\/"ò gYv *Ug)pXc a÷              // implicit: U = input integer
o.5,.5,XYZ{UaXc)ç +"--/\\\\/"ò gYv *Ug)pXc a} qR    // ungolfed
o.5,.5,                                             // array [.5,U] with step size .5
       XYZ{                                 }       // mapped by the function: (X = value, Y = index)
           UaXc)                                    //   absolute diff between U and ceil(X)
                ç                                   //   " " times that value
                  +"--/\\\\/"ò g      )             //   plus ["--","/\","\/"].get(...
                                Yv                  //     if Y is even, 1, else 0
                                   *Ug              //     times sign(U)
                                       pXc a        //   repeated abs(ceil(X)) times
                                              qR    // all that joined with newlines

Comments

38 बाइट्स ।

— शैगी

Answer 8

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

:┅“/\\“--”צ¦_€|ḣ¤ọ×ṣ

व्याख्या

:                      Push 2 copies of the input
 ┅                     Get the range to the input. If positive: [1 .. n]. If negative: 
                       [-1 .. n]. If zero: [0].
  “/\\“--”             Push ["/\", "--"]
          צ¦          Repeat both of those strings by each number in the range. Strings go
                       in reverse order when repeated a negative number of times.
             _         Flatten the list
              €|       Centre-align the rows of the list
                ḣ      Remove the last row (the "--"s on the bottom)
                 ¤     Swap (bring input back to the top)
                  ọ    Sign: -1 for negative, 0 for 0, 1 for positive
                   ×   Repeat the list that many times; (-1 × list) reverses it
                    ṣ  Join with newlines and implicitly output

Answer 9

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

(T=Table;z=Column;B[a_]:=""<>"/\\"~T~a;If[#>0,m=0,m=Pi];z[Join[z/@T[{B@i,""<>"--"~T~i},{i,Abs@#-1}],{B@Abs@#}],Alignment->Center]~Rotate~m)&

Answer 10

रेटिना , 116 111 105 बाइट्स

यह रास्ता बहुत लंबा हो गया: /

\d+
$*
+`^~?( *1*)1
 $1¶$&¶_$&
.*$

+`(_.*)1
$1--
1
/\
Ts`/\\`\\/`.*~.*
+`(.*)¶((.*¶)*)(~.*)
$2$4¶$1
~|_

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

नकारात्मक इनपुट के रूप में चिह्नित किया जाता है ~n

Answer 11

पर्ल 5 , 100 + 1 (एन) = 101 बाइट्स

$/=$_>0?'/\\':'\\/';push@r,$_=$"x--$q.$/x$_,y|/\\|-|r for 1..($q=abs);pop@r;say for$_<0?reverse@r:@r

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