कुछ ASCII गहने ले लो!

Question

13 मार्च को राष्ट्रीय गहना दिवस के रूप में मान्यता प्राप्त है , जो इस चुनौती का विषय है। इसलिए, पूर्णांक दिया गया है nजहां n0 से अधिक है, एक ASCII गहना बनाएं। उदाहरण के लिए:

n = 1          n = 2             n = 3
                                       ______
                     ____             /      \
 __                 /    \            \      /
/  \                \    /             \    /
\  /                 \  /               \  /
 \/                   \/                 \/

नीचे के सबसे उच्च जोड़ी के लिए गहना के बहुत नीचे के रूप में परिभाषित किया गया है \/। शेष शीर्ष है। उपरोक्त उदाहरण के लिए जहां n = 1:

Bottom: \  /    Top:   __
         \/           /  \

जैसा कि आप देख सकते हैं, नीचे गहना के नीचे से अधिकतम लाइनों n + 1के \/साथ (1 * lines from the bottom) * 2रिक्त स्थान की परतों से बना है n। यदि हम दूसरा गहना लेते हैं ( n = 2), तो हम यह देख सकते हैं:

 ____
/    \      
\    /  2 (or n) layers from the bottom with 1*2*2 or 4 spaces in between \/
 \  /   1 layer from the bottom with 1*1*2 or 2 spaces in between \/
  \/    The bottom (0 layers) with 1*0*2 spaces or 0 spaces in between \/

शीर्ष शीर्ष पर अंडरस्कोर के साथ बीच में रिक्त स्थान के /\साथ एक जोड़ी से बना है ।n*2n*2

नियम

• उपयोगकर्ता इनपुट के रूप में किसी भी गैर-धनात्मक धनात्मक पूर्णांक में ले जाने में सक्षम होना चाहिए
• ऊपर परिभाषित स्पेक्स के साथ एक गहना बनाना चाहिए (यहाँ विश्राम किया गया है):
  • शीर्ष शीर्ष पर अंडरस्कोर के साथ बीच में रिक्त स्थान के /\साथ एक जोड़ी से बना है ।n*2n*2
  • नीचे ज्वेल के नीचे से अधिकतम लाइनों n + 1के \/साथ (1 * lines from the bottom) * 2रिक्त स्थान की परतों के साथ बना है n।
• गहना के बाद नई अनुगामी, या प्रत्येक पंक्ति पर अनुगामी रिक्त स्थान की अनुमति है।
• कोई मानक खामियों की अनुमति नहीं है

जीत का मानदंड

कम से कम बाइट्स जीत!

Comments

कड़ाई से "नॉनज़रो पॉज़िटिव" बोलना निरर्थक है - यदि आप 0 को शामिल करना चाहते हैं, तो आपको "नॉनगेटिव" कहना होगा।

— निधि मोनिका का मुकदमा

क्या इसका जवाब PETSCII में हो सकता है?

— शॉन बेबर्स

जैसा कि संख्या अधिक हो जाती है "गहने" कम दिखने लगते हैं जैसे गहने और पिज्जा स्लाइस की तरह अधिक, या शायद यह सिर्फ दोपहर के भोजन की बात कर रहे हैं।

— मेराज स्टिविंग

Answer 1

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

कोड:

ＮβＧ←β_↙↙¹→↘⁺β¹‖Ｍ→

स्पष्टीकरण:

Ｎβ                      # Place the input into β
   Ｇ←β_                 # Draw a line of length β with _ as the filling character
        ↙                # Move the cursor one down and one left
         ↙¹              # Draw a line from the cursor position to one position ↙
           →             # Move the cursor 1 to the right
             ⁺β¹         # Add one to the input and..
            ↘            # Create a line pointing ↘, with the size calculated above
                ‖Ｍ→     # Mirror to the right

एक बहुत साफ-सुथरी कमान है ‖Ｍ, जो अपने आप में दर्पण भी बन /जाती है \।

चारकोल एन्कोडिंग का उपयोग करता है ।

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

Comments

उस दर्पण आदेश वास्तव में अच्छा है! क्या यह दर्पण कोष्ठक और अन्य वर्ण भी है? और क्या उस व्यवहार को ओवरराइड करने का एक तरीका है?

— DJMcMayhem

@DJMcMayhem हाँ और हाँ :)

— अदनान

योग्य, आपने हीरे को चारकोल से बाहर कर दिया!

— स्टेवड्रोज़

Answer 2

05AB1E , 27 20 बाइट्स

ƒN·ð×…\ÿ/}¹·'_×)R.c

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

व्याख्या

ƒ                      # for N in range[0 ... n]
 N·ð×                  # push N*2 spaces
     …\ÿ/              # push the string "\ÿ/" with "ÿ" replaced by the spaces 
         }             # end loop
          Â            # push a reversed copy of the top of the stack 
                       # (the largest row of the bottom of the diamond)
           ¹·'_×       # push input*2 underscores
                )      # wrap the stack in a list
                 R     # reverse the list
                  .c   # join the list on newlines, padding each row to equal length

Comments

हा हा बड़िया! मेरा मानना है कि आप बदल सकते हैं D„/\„\/‡करने के लिए Â।

— अदनान

@ अदनान: हाँ, मुझे एहसास हुआ कि खुद को

— सुधारते

Answer 3

पायथन 2, 101 98 95 बाइट्स

lambda n:'\n'.join([' '+'__'*n,'/'+'  '*n+'\\']+[' '*i+'\\'+'  '*(n-i)+'/'for i in range(n+1)])

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

अनाम फ़ंक्शन जो एक सकारात्मक पूर्णांक में लेता है और एक स्ट्रिंग लौटाता है

पायथन 3.6, 92 बाइट्स (बेन फ्रैंकल को धन्यवाद)

lambda n:f' {"__"*n}\n/{"  "*n}\\\n'+'\n'.join(' '*i+'\\'+'  '*(n-i)+'/'for i in range(n+1))

मुझे इस संस्करण के लिए एक ऑनलाइन दुभाषिया नहीं मिला, लेकिन v3.6 में f- स्ट्रिंग्स के कारण यह थोड़ा छोटा है

Comments

आप पायथन 3.6 में तीन बाइट्स बचा सकते हैं lambda n:f' {"__"*n}\n/{" "*n}\\\n'+'\n'.join(' '*i+'\\'+' '*(n-i)+'/'for i in range(n+1)):। एफ-स्ट्रिंग्स का लाभ उठाते हुए।

— बेन फ्रेंकल

मुझे पूरा यकीन है कि इसका उत्तर पायथॉन 3 के लिए एक परीक्षण सूट है

— एंथनी फाम

@AnthonyPham repl.it और TryItOnline दोनों पायथन 3.5 का उपयोग करते हैं, मैंने चेक किया है

— गणित जंकी

वाह, आखिर! मुझे आश्चर्य है कि अजगर ने इतनी देर तक क्या किया। हर भाषा स्ट्रिंग

— इंटरपलेशन की

Answer 4

PHP, 123 बाइट्स

echo($s=str_pad)(" ",$z=1+2*$a=$argv[1],_).$s("\n/",$z+1," ")."\\\n";for($i=0;$i<=$a;)echo$s($s("",$i)."\\",$z-$i++)."/\n";

143 बाइट्स पहला संस्करण

for(;$i<3+$a=$argv[1];$i++)echo 1-$i?str_pad("",$i?$i-2:1):"/",str_pad($i>1?"\\":"",$i<2?2*$a:2*($a-$i+2)+1,$i?" ":_),$i<2?$i?"\\":"":"/","\n";

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

Comments

मैं यह कहां कोशिश कर सकता हूं?

— एंथोनी फाम

@AnthonyPham यहाँ ।

— अदनान

आप इसे 119 बाइट्स बना सकते हैं: ideone.com/RPCVZe

— Tschallacka

@Tsllllacka अगर मुझे लगता है कि मैं केवल एक लिनक्स

— साइटम का

खैर, जब तक आप notepad.exe के साथ संपादित नहीं करते हैं, तब तक अधिकांश संपादकों की लाइन लाइन अंत होती है ... i.imgur.com/QZsmf4r.png विंडोज़ कंसोल एक वास्तविक नई रेखा के रूप में खुशी से \ n प्रदर्शित करेगा। तो, हाँ, आप अपने जवाब के कुछ बाइट्स दाढ़ी कर सकते हैं।

— शाचलैक

Answer 5

वी , 28 27 26 बाइट्स

1 बाइट्स के >बजाय @DJMcMayhem का उपयोग करके धन्यवाद को बचाया गयाÉ

Ài__<esc>É ÙÒ r/Á\Ùr\$r/òÙlxx>

<esc> है 0x1b

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

Hexdump:

00000000: c069 5f5f 1bc9 20d9 d220 722f c15c d972  .i__.. .. r/.\.r
00000010: 5c24 722f f2d9 6c78 783e                 \$r/..lxx>

व्याख्या

शीर्ष:

Ài__<esc>              " Write argument times __
É<space>               " Prepend a space to the line
Ù                      " Duplicate line below cursor, cursor also moves down
Ò<space>               " Replace every character with a space
r/                     " Change the first character in the line to a /
Á\                     " Append a \ to the end of the line

तल:

Ù                      " Duplicate
r\                     " Change the first character in the line to a \
$r/                    " Replace the last character with a /
ò                      " Until a breaking error occurs do:
  Ù                    "  Duplicate
  lxx                  "  Remove 2 middle characters (spaces)
  >                    "  Indent by one space (implicit ending >)
                       " Implicit ending ò

Comments

अच्छा जवाब! आप बदल सकते हैं É<space>करने के लिए >जो एक मैक्रो के अंत में परोक्ष में भर जाता है>>

— DJMcMayhem

@DJMcMayhem अच्छा सुझाव! तो >एक टैब के बजाय एक जगह पर संकेत देता है?

— कृति लिथोस

हां! के कारण यही कारण है कि मेरे पास है set expandtabऔरset shiftwidth=1

— DJMcMayhem

Answer 6

रोड़ा , 71 बाइट्स

f n{a=" ";[a,"__"*n,"
/",a*2*n,`\
`];seq n,0|[a*(n-_),`\`,a*2*_1,"/
"]}

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

Answer 7

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

f=
n=>` ${"_".repeat(n*2)}
/${s=" ".repeat(n)}${s}\\`+s.replace(/|/g,"\n$`\\$'$'/")

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

Answer 8

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

n,s=int(input())," "
print(s+n*"__","/"+n*2*s+"\\",*[i*s+"\\"+2*(n-i)*s+"/"for i in range(n+1)],sep="\n")

स्टडिन से एक उदाहरण लेता है

Answer 9

MATL , 34 बाइट्स

QE:qgOO(t~E3O(GQXy3*tPgEhv'_/\ 'w)

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

QE:qg   % Create array [0 1 1 ... 1 1] of size2*(n+1)
OO(     % Turns last 1 into a 0: [0 1 1 ... 1 0]
t~      % Duplicate and negate: [1 0 0 ... 0 1]
E3O(    % Multiply by 2, turn last 2 into 3: [2 0 0 ... 0 3]
GQXy    % Push identity matrix of size n+1
3*      % Multiply by 3
tPgE    % Duplicate, flip, turn 3 into 2
h       % Concatenate the two matrices horizontally
v       % Concatenate all arrays vertically into a matrix
'_/\ '  % Push this string
w)      % Index (modular, 1-based) with the matrix into the string. Implicitly display

Answer 10

पॉवरशेल , 76 , 74 बाइट्स

param($n)" "+'_'*2*$n;"/$(' '*$n*2)\";$n..0|%{' '*($n-$_)+"\$(' '*$_*2)/"}

नोट: ऑनलाइन उदाहरण में प्रदर्शन के रूप में रैपिंग का एक सा होता है। निष्पादित करने के लिए एक पोस फ़ंक्शन या स्क्रिप्ट में रखें।

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

Comments

PPCG में आपका स्वागत है! अच्छा पहला जवाब, और आसपास एक और PowerSheller देखकर अच्छा लगा! आप लूप में एक वृद्धिशील चर का उपयोग करके कुछ बाइट्स बचा सकते हैं - के ' '*$i++बजाय ' '*($n-$_)।

— AdmBorkBork

Answer 11

सी, 131 बाइट्स

i;f(n){for(printf(" ",i=0);i++<n*2;)printf("_");for(printf("\n/%*c\n",n*2+1,92,i=0);i++<n+1;)printf("%*c%*c\n",i,92,(n-i)*2+3,47);}

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

Comments

मैं यह कहां से परख सकता हूं?

— एंथनी फाम

@AnthonyPham Tio लिंक जोड़ा गया।

— स्टेयडबॉक्स

रिक्त स्थान भरने के लिए प्रिंटफ की चौड़ाई का उपयोग करके अच्छा तरीका। यदि आप प्रिंटफ के लिए मैक्रो बनाते हैं तो आप 9 और बाइट्स बचा सकते हैं, पहले i = 0 को हटा दें और दूसरे रन पर i-0 को फिर से इनिशियलाइज़ करने के बजाय एक नया वेरिएबल j जोड़ें:i,j;f(n){for(p(" ");i++<n*2;p("_"));for(p("\n/%*c\n",n*2+1,92);j++<n+1;p("%*c%*c\n",j,92,(n-j)*2+3,47));}

— क्लाउडी

@Claudiu धन्यवाद, लेकिन तब फ़ंक्शन सही आउटपुट का उत्पादन करेगा जब इसे पहली बार कहा जाता है, और IIRC यहां नियमों के खिलाफ है। फ़ंक्शन को कोई भी काम नहीं करना चाहिए चाहे इसे कितनी बार कहा जाए।

— स्टेडीबॉक्स

@Steadybox ओह, मैं देख रहा हूँ, इसके लिए क्षमा करें। क्या यह सभी कोडगॉल्फ प्रश्नों के लिए लागू होता है? बस इस विशिष्ट प्रश्न को देखकर ऐसा नहीं लगता है कि यह कई इनपुट चाहता है।

— क्लॉडिउ

Answer 12

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

+" "*Q"__"++\/**2Qd\\jm+++*d\ \\**2-Qd\ \/hQ

कोशिश करो!

व्याख्या

कोड में 3 भाग होते हैं:

+" "*Q"__"               # pretty straightforward " "+input()*"__"
++\/**2Qd\\              # d is defined as " ":  "/"+2*input()*d+"\"
jm+++*d\ \\**2-Qd\ \/hQ  # The third part is a bit more complex so I'll explain it further:

jm                   hQ  # Map some lambda function onto range(input()+1) and join the result on newlines
  +++*d\ \\**2-Qd\ \/    # Here d is the lambda argument (so I can't use it for spaces -.-) 
  +++*d\ \\**2-Qd\ \/    # In Python: d*" "+"\\"+2*(Q-d)*" "+"/"

Answer 13

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

n=int(input());print(" "+"__"*n+"\n/"+"  "*n+"\\")
for i in range(n+1):print(" "*i+"\\"+"  "*(n-i)+"/")

कार्यक्रम STDIN से पूर्णांक लेता है और STDOUT में गहना लौटाता है।

Answer 14

रंज , 43 बाइट्स

-nध्वज के लिए कोड के 42 बाइट्स, +1 ।

Ps.'_Xa*2P"/\"JsXa*2sX_.'\.sXa-_X2.'/M,a+1

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

व्याख्या

पहले दो पंक्तियों को अलग-अलग बनाता है, फिर बाकी का गहना एक मैप ऑपरेशन के साथ:

Ps.'_Xa*2
      a*2  Cmdline arg, times 2
   '_X     That many underscore characters
 s.        Concatenated to a space character
P          Print (with newline)

P"/\"JsXa*2
        a*2  Cmdline arg, times 2
      sX     That many space characters
 "/\"J       Join the string "/\" with the above as the separator
P            Print (with newline)

sX_.'\.sXa-_X2.'/M,a+1
                  ,a+1  Numbers from 0 up to and including a
                 M      Map the following lambda function:
sX_                      Space, repeated (fn arg) times
   .'\                   Concatenate \
      .                  Concatenate:
       sXa-_              Space, repeated (a - (fn arg)) times
            X2            repeated twice
              .'/        Concatenate /
                         Print result list, newline separated (implicit, -n flag)

एक और समाधान

इस समय -lध्वज के साथ 42 + 1 बाइट्स :

Ys.tAL'_.sX2+,a.0(yALRVyRXD1-_)R0'\R1'/ZDs

TIO

Answer 15

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

j[*yQ\_j*yQpd"/\\"jm+*\ dj*\ y-Qd"\/"h

Answer 16

सी, 115 बाइट्स

#define p printf(
i;j;f(n){for(p" ");i++<n;p"__"));for(p"\n/%*c",2*n+1,92);j<=n;p"\n%*c%*c",++j,92,n*2-j*2+3,47));}

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

सी, 123 बाइट्स

हालांकि चुनौती को इसकी आवश्यकता नहीं है, 8 बाइट्स की कीमत पर फ़ंक्शन को पुन: प्रयोज्य बनाया जा सकता है (पहला समाधान वैश्विक चर के अनुमानित आरंभ पर भरोसा करके 8 बाइट्स बचाता है)।

#define p printf(
i;f(n){for(i=0,p" ");i++<n;p"__"));for(i=0,p"\n/%*c\n",2*n+1,92);i<=n;p"%*c%*c\n",++i,92,n*2-i*2+3,47));}

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

Answer 17

बैच, 152 बाइट्स

@set s=
@for /l %%i in (1,1,%1)do @call set s=  %%s%%
@echo  %s: =_%
@echo /%s%\
@set s=\%s%/
:l
@echo %s%
@if %s:~-2%==/ set s=%s:\  = \%&goto l

टेस्ट:

n = 1
 __
/  \
\  /
 \/

n = 2
 ____
/    \
\    /
 \  /
  \/

n = 3
 ______
/      \
\      /
 \    /
  \  /
   \/

Comments

मुझे इसका परीक्षण करने के लिए एक परीक्षण सूट की आवश्यकता होगी।

— एंथनी फाम

Answer 18

सी #, 187 बाइट्स

मुझे यकीन है कि वहाँ एक और अधिक कॉम्पैक्ट समाधान है, लेकिन यह मेरा पहला प्रयास है:

var a=" "+new string('_',2*n)+"\n/"+new string(' ',2*n)+"\\\n";for(int i=n;i>0;i--){a+=new string(' ',n-i)+"\\"+new string(' ',2*i)+"/\n";}a+=new string(' ',n)+"\\/";Console.Write(a);

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

Comments

मुझे इसका परीक्षण करने के लिए एक परीक्षण सूट की आवश्यकता होगी।

— एंथनी फाम

Answer 19

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

n=>(` 0
/2\\`+`
1\\4/`.repeat(k=++n)).replace(/\d/g,c=>' _'[+!+c].repeat(c&1?k-n-2:+c+--n*2))

डेमो

let f =

n=>(` 0
/2\\`+`
1\\4/`.repeat(k=++n)).replace(/\d/g,c=>' _'[+!+c].repeat(c&1?k-n-2:+c+--n*2))

console.log(f(1))
console.log(f(2))
console.log(f(3))

Answer 20

डीसी , 121 बाइट्स

?d1+sa2*sb32P[0sq[lvPlq1+dsqlj>h]shlj0<h]srlbsj95svlrx2607Plbsj32svlrx[\]p0sd[ldsjlrx92Plbsjlrxlb2-sb[/]pld1+dsdla>k]dskx

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

Answer 21

पर्ल 5 109 94 + 1 (ध्वज-पी के लिए) = 95 बाइट्स

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

$l=$_*2;$s=" "."_"x$l."\n/"." "x$l."\\\n";$s.=" "x$_."\\"." "x($l-$_*2)."/\n"for 0..$_;print$s

ऐसे चलाया जा सकता है:

perl -p <name of file> <<< n

Ungolfed

$l=$_*2;
$s=" "."_"x$l."\n/"." "x$l."\\\n";
$s.=" "x$_."\\"." "x($l-$_*2)."/\n"for 0..$_;
print$s

व्याख्या

#Sets $l to twice the value of the input 'n'
$l=$_*2;  

#Top 2 rows of jewel adding $l underscores then newline  
#followed by '/' and $l spaces.  The '\\\n' is an escaped '\' and a newline
$s=" "."_"x$l."\n/"." "x$l."\\\n";

#The meat of the jewel generation.  It contains a for-loop
#that iterates from 0 to $_ (the input value 'n')
#The loop uses its iterator value ($_ (which overrides the outer $_))
#to determine how many leading spaces it needs to apply.
#Then it adds a '\' with '\\' followed by $l-$_*2 number of spaces
#(the inside of the jewel).  Again, while under the umbrella of the for-loop,
#the $_ refers to the iterator value of the for-loop.
#After the inner spaces, it goes on to add in the '/' and a new line
$s.=" "x$_."\\"." "x($l-$_*2)."/\n"for 0..$_;

#Lastly, it prints the compiled Scalar value $s.  (In Perl, Strings are Scalar values or references
print$s

Comments

मुझे इसका परीक्षण करने के लिए एक परीक्षण सूट की आवश्यकता होगी क्योंकि हर कोई इसे नहीं समझता है या आपके द्वारा बताए गए तरीके से इसे चलाने की क्षमता है

— एंथनी फाम

@AnthonyPham मैंने ऑनलाइन लिंक की कोशिश की

— CraigR8806