एक तारांकित त्रिकोण बनाएं

57

101 के प्रोग्रामिंग के लिए एक कार्य से प्रेरित है यहां एक ऐसा काम है जो उम्मीद के मुताबिक बहुत आसान नहीं है या एक डुप्लिकेट है (जैसी चीजों के लिए खोज करना कठिन है)।

इनपुट:

  • एक सकारात्मक पूर्णांक n >= 1।

आउटपुट:

  • n तारांकन रेखाएँ, जहाँ हर नई रेखा में पहले की तुलना में एक तारांकन अधिक होता है, और पहली पंक्ति में एक तारांकन के साथ शुरू होता है।

सामान्य नियम:

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

टेस्ट केस (n = 5):

*
**
***
****
*****
code-golf  ascii-art 
— बीमार लड़का
स्रोत
6
डुप्लिकेट नहीं, बस एक सही त्रिकोण उत्पन्न करें ।
— मैनटवर्क
2
प्रत्येक स्थान पर प्रशिक्षण रिक्त स्थान की अनुमति है?
— लुइस मेंडो
2
क्या एक अनुगामी नई रेखा स्वीकार्य है?
— घातक
1
एक अग्रणी नईलाइन की अनुमति है?
— रिले
मुझे कोई कारण नहीं दिखता कि क्यों नहीं।
— सिकलबॉय

जवाबों:

41

विम, 8 बाइट्स

o <Esc><C-V>{r*J

रीडहेड बफर में इनपुट लेता है, इसलिए यदि इनपुट 15 है, तो आप इसे टाइप करेंगे और फिर ऊपर कोड। यह एक मूर्खतापूर्ण नियम है, लेकिन लगता है किए जाने की अनुमति दी । यदि आपको किसी रजिस्टर में इनपुट मिला है "a, तो आप बस @aसामने (10) चिपके रहेंगे । यदि आपको यह आरंभिक फ़ाइल से मिला है, तो आप D@"इसके बजाय (11) पूर्व निर्धारित करेंगे ।

दुरुपयोग पर निर्भर करता है :set autoindent, जो कि vimgolf.com नियमों में डिफ़ॉल्ट है और विम 8 में डिफ़ॉल्ट है (और हर कोई इसे वैसे भी उपयोग करता है)।

  • o <Esc>: इसकी संख्या तर्क के साथ, यदि आपका पाठ व्हॉट्सएप से शुरू होता है, और आपके पास है :set autoindent, विम बाहर निकलता है और इंडेंट का झरना बनाता है।
  • <C-V>{r*: उन सभी रिक्त स्थान को चालू करें *। मैं ब्लॉक विजुअल का उपयोग कर रहा हूं, ताकि भले ही आपकी घटिया इंडेंट सेटिंग आपके स्पेस को टैब में ग्रुप कर दें, फिर भी आपको सही संख्या मिल जाएगी *।
  • J: oदुर्भाग्य से शुरू करके शीर्ष पर एक रिक्त रेखा छोड़ दी गई। यह उसे दूर करता है।
— udioica
स्रोत
1
यह उत्तर पागलपनपूर्ण है। मैंने देखा है सबसे अच्छे उत्तर में से एक।
— DJMcMayhem
1
यह मछली की तरह दिखता है। या एक रॉकेट।
— स्टीफन बिजिटिटर
1
मैंने थोड़ा घुमाया और विम को -u NONEअपने आप से यह देखने के लिए निकाल दिया ... यह काम नहीं किया, ऐसा लगता autoindentहै कि डिफ़ॉल्ट vimrc में है , 8 ही नहीं vim इसलिए मुझे इसे मैन्युअल रूप से चालू करना था। लेकिन, इस जवाब की सरलता के लिए नफरत करता है! लेकिन प्रति नई लाइन में केवल एक ही स्थान क्यों है? यह केवल रिक्त स्थान के साथ काम क्यों करता है लेकिन अन्य पात्रों के साथ नहीं? मुझे अभी भी बहुत कुछ सीखना
— बाकी
अंत में शुरू करने O <Esc>की आवश्यकता नहीं होगी J।
— प्राइमो
1
@ वर्जिनिका एक एकल अनुगामी न्यूलाइन आमतौर पर स्वीकार्य मानी जाती है।
— प्रिमो
23

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

इसमें एक अग्रणी और एक अनुगामी लाइन-ब्रेक दोनों शामिल हैं।

हम एक स्ट्रिंग के साथ शुरू करते हैं sजिसमें केवल एक लाइन-ब्रेक होता है। फिर हम nपुनरावृत्ति कॉल की प्रक्रिया करते हैं, प्रत्येक स्ट्रिंग में इस स्ट्रिंग के बाईं ओर एक तारांकन जोड़ते हैं। सभी मध्यवर्ती तारों का संघनन अपेक्षित परिणाम की ओर ले जाता है।

f=(n,s=`
`)=>n?s+f(n-1,'*'+s):s

तारांकन के बिना, 36 बाइट्स

f=(n,s=`
`)=>n?s+f(n-1,atob`Kg`+s):s
— Arnauld
स्रोत
यह कैसे काम करता है ?
— एलेक्सिस_ए
1
@Alexis_A - मैंने एक छोटा विवरण जोड़ा है।
— अरनुलद
3
अच्छा पुनरावर्ती उत्तर; मैंने कभी भी आपके द्वारा इस्तेमाल की जाने वाली तकनीक के बारे में नहीं सोचा होगा s। आप इसे थोड़ा कम गूढ़ बना सकते हैं n?s+f(n-1,'*'+s):s।
— ETHproductions
19

05AB1E , 7 6 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

'*×.p»

8 बाइट नहीं-तारांकन संस्करण:

žQTè×.p»

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

व्याख्या

इनपुट का उपयोग कर उदाहरण n = 5

'*      # push "*"
        # STACK: "*"
  ×     # repeat input number times
        # STACK: "*****"
   .p   # get prefixes of string
        # STACK: ['*', '**', '***', '****', '*****']
     »  # join by newlines
        # implicit print
— Emigna
स्रोत
@BitByte 10žQSè×.p»इस उत्तर का एक तार्किक विस्तार है कि आप बाउंटी के लिए क्या चाहते हैं और यह केवल 10 बाइट्स है। अगर कोई भी 10 बाइट्स नहीं मारता है, तो एमिगा को इनाम दें।
— मैजिक ऑक्टोपस Urn
1
@ आरोसोकोम्पुटिंग: TžQè×.p»8 बाइट्स भी है।
— एमिगा
अभी भी भाषा सीखने की कोशिश कर रहा है, टी निर्देश याद किया; यह अजीब था कि बेस 2 पुश का एक टन था, लेकिन कोई आधार नहीं। 10. मुझे अभी भी जानकारी की संपूर्ण सामग्री को परिमार्जित करना है। उस भाषा में कुछ भी करने में सक्षम होने के लिए जानकारी की संपूर्ण सामग्री।
— मैजिक ऑक्टोपस Urn
@carusocomputing कुछ आदेशों को याद करना वास्तव में आसान है, खासकर यदि आप इसे करने का एक और तरीका जानते हैं :)
— एमिग्ना
1
@ क्रूसोकोम्पुटिंग: सुनिश्चित नहीं है कि आप क्या उल्लेख कर रहे हैं। एकमात्र सूची कमांड जो मैं यहां उपयोग कर रहा हूं »और वह विशेष रूप से एक सीमांकक के साथ सूचियों को एक स्ट्रिंग में विलय करने के लिए एक कमांड है (और Sइसे बर्बाद कर देगा)। लेकिन बहुत सारे 05AB1E कमांड वेक्टर करते हैं, हाँ।
— एमिग्ना
15

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

1..$args[0]|%{'*'*$_}

1इनपुट से लूप $args[0], स्ट्रिंग के गुणन का उपयोग करके प्रत्येक पुनरावृत्ति, जिसमें कई $_तारांकन होते हैं। Write-Outputअंत में निहित के लिए डिफ़ॉल्ट व्यवहार विभाजक के लिए एक नई रेखा के साथ है, इसलिए हमें वह मुफ्त में मिलता है।

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 5
*
**
***
****
*****

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 2
*
**

PS C:\Tools\Scripts\golfing> .\draw-asterisk-pattern.ps1 7
*
**
***
****
*****
******
*******
— AdmBorkBork
स्रोत
13

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

i=1;exec"print'*'*i;i+=1;"*input()

Ideone

iआरंभिक है 1;
फिर execकोड के निम्नलिखित स्ट्रिंग को निष्पादित करने की आज्ञा देता है, इसलिए इसका निर्माण किया जाना चाहिए;
स्ट्रिंग है, "print'*'*i;i+=1;"लेकिन *निम्नलिखित स्ट्रिंग पर पूर्वता लेता है execऔर पहले स्ट्रिंग input()बार दोहराने का निर्देश देता है ; आदेश अब लंबी स्ट्रिंग जो एक पाश की तरह कार्य करता है, कार्यान्वित लंबाई में वृद्धि का एक और स्ट्रिंग ing, फिर से उपयोग करने चरित्र को दोहराने के लिए , तो incrementing के साथ ।
execprint*'*'ii+=1

पायथन 3, 41 बाइट्स
def f(n):i=1;exec("print('*'*i);i+=1;"*n) :; या
lambda n,i=1:exec("print('*'*i);i+=1;"*n)

— जोनाथन एलन
स्रोत
13

जेली , 6 5 बाइट्स

”*ẋþY

TryItOnline

कैसे?

”*ẋþY - Main link: n
”*    - literal string "*"
   þ  - form outer product with the dyadic function:
  ẋ   -     repeat list (right input is an implicit range(n), Jelly defaults to 1-based)
            so the outer product is like:
            [[i*'*' for i in range(1,len("*")+1)] for x in range(1,n+1)]
    Y - join with line feeds
      - implicit print

बाउंटी:
मुझे यकीन है कि क्या कोई ऑर्डिनल्स खंड है नहीं कर रहा हूँ के बाद से एक चरित्र है एक क्रमसूचक के देखने।
प्रत्यक्ष लुकअप केवल 7 बाइट्स के42Ọẋþ³Y लिए होगा - जहां हमें इनपुट मिलता है) एक छोटा सा अप्रत्यक्ष तरीका होगा, 8 बाइट्स के लिए , - जहां हम जेली के कोड पृष्ठ में देखते हैं, जो 1-अनुक्रमित है इसलिए पैदावार 42 है।³
“)’Ọẋþ³Y')'“)’

— जोनाथन एलन
स्रोत
जब आप इनपुट में एक अग्रणी 0 का उपयोग करते हैं, तो कुछ दिलचस्प होता है। इनपुट के रूप में "0414141" का प्रयास करें। मैं गोल्फ की भाषाओं में क्लूलेस हूं इसलिए मुझे नहीं पता कि इसे समझाने की कोशिश कहां से शुरू करूं।
— ल्यूक
मुझे लगता है कि यह एक स्ट्रिंग के रूप में मूल्यांकन किया जाता है और इसलिए यह एक पार के रूप में पुनरावृत्त होता है एक स्ट्रिंग के रूप में एक पुनरावृत्ति होती है और फिर प्रत्येक वर्ण एक पूर्णांक के लिए मूल्यांकन करता है क्योंकि वे सभी अंक हैं (उदाहरण के लिए "hi" के साथ यह त्रुटि होगी)
— जोनाथन एलन
11

सी #, 42 बाइट्स

f=n=>n<1?"":f(n-1)+"\n"+new string('*',n);

परीक्षण कार्यक्रम के साथ पूरा कार्यक्रम:

using System;

namespace DrawAnAsteriskPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,string>f= null;
            f=n=>n<1?"":f(n-1)+"\n"+new string('*',n);

            Console.WriteLine(f(5));
        }
    }
}
— adrianmp
स्रोत
एक पुनरावर्ती कार्य के बाद से आपको इसकी आवश्यकता है।
— adrianmp
सही। यह नहीं देखा
— Cyoce
9

GNU sed , 25 24 20 + 1 (n झंडा) = 21 बाइट्स

संपादित करें: रिले की टिप्पणियों के आधार पर 4 बाइट्स कम

x;G;:;P;s:\n.:*\n:;t

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

रन उदाहरण: इनपुट एकात्मक प्रारूप में है, जो इस आम सहमति के आधार पर सेड के लिए अनुमत है

me@LCARS:/PPCG$ sed -nf draw_triangle.sed <<< "0000"

*
**
***
****

आउटपुट में एक प्रमुख न्यूलाइन मौजूद है, लेकिन ओपी द्वारा इसकी अनुमति है।

स्पष्टीकरण:

x;G             # prepend a newline to unary string
:               # start loop
   P            # print first line only
   s:\n.:*\n:   # shift one unary char from 2nd line to 1st, converted to a '*'
t               # repeat
— seshoumara
स्रोत
यदि आप Pप्रतिस्थापन से पहले रिंट करते हैं और एक अग्रणी नईलाइन की अनुमति है तो आपको इसकी आवश्यकता नहीं है /0$/। यदि एक नई पंक्ति की अनुमति नहीं है, तो आप अभी भी एक बाइट बचा सकते हैं x;G;:;/*/P;s:\n.:*\n:;t। मैंने एक प्रमुख समाचार के बारे में पूछा, लेकिन अभी तक वापस नहीं सुना है।
— रिले
8

मतलाब, 26 23 बाइट्स

अच्छा पुराना मतलब ...

@(n)tril(repmat('*',n))

व्हाट्सएप को पीछे छोड़ रहा है। trilआपको निम्न त्रिकोणीय मैट्रिक्स देता है।

संपादित करें: लुइस मेंडो के लिए धन्यवाद 2 bythes बचाया

— mathause
स्रोत
आप सही हैं - धन्यवाद - अभी भी बहुत प्रतिस्पर्धी नहीं है: पी
— मैथ्यूज
8

सी ++ - 92 96 बाइट्स

#include<string>
int main(){int n;std::string s;scanf("%d",&n);for(;n--;)puts((s+="*").data());}

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

Ungolfed:

//this one hurts, but c++ strings are mutable
#include<string> 
int main(){
    int n;
    //this one hurts as well
    std::string s; 
    //read input to n
    //longer than 'std::cin>>n', but no #include<iostream> needed
    scanf("%d",&n); 
    // same as 'while(n--)', also characterwise, but way cooler
    for(;n--;) 
        //add a '*' the string
        //data() does the same as c_str()
        //puts automatically adds an '\n'
        puts((s+="*").data()); 
}
— Anedar
स्रोत
+4 बाइट्स के लिए 'int main () {}' होना चाहिए।
सच, लानत है - तो गैर-मानक व्यवहार gcc / ideone की
— Anedar
7

जेलिफ़िश , 12 11 9 बाइट्स

\P$'*
  i

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

व्याख्या

उपरोक्त कार्यक्रम निम्नलिखित कार्यात्मक छद्मकोश के बराबर है:

\            P      $       i        '*
map_prefixes(print, reshape(input(), '*'))

$(आकृति बदलें) की एक स्ट्रिंग बनाता Nतारक। \Pएक फ़ंक्शन बनाता है जो एक सूची (या स्ट्रिंग) लेता है और इसके प्रत्येक उपसर्ग को P(प्रिंट) पास करता है। इसलिए, यह क्रमिक तार के तार को प्रिंट 1करता Nहै।

— मार्टिन एंडर
स्रोत
7

आर, 45 बाइट्स

पाश दृष्टिकोण के लिए:

for(i in 1:scan())cat(rep("*",i),"\n",sep="")
— Billywob
स्रोत
6

ब्रेकीलॉग , 12 बाइट्स

yke:"*"rj@w\

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

यह मानता है कि अनुगामी नई रेखा स्वीकार्य है

व्याख्या

yk                The range [0, …, Input - 1]
  e               Take one element I of that range
   :"*"rj         Juxtapose "*" I times to itself
         @w       Write that string followed by a new line
           \      False: backtrack to another element of the range

कोई अनुगामी नई पंक्ति, 15 बाइट्स

-:"*"rj:@[f~@nw

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

यह सभी के उपसर्गों को ले कर काम करता है "*" × Input।

— Fatalize
स्रोत
6

हास्केल, 35 38 बाइट्स

निम्मी को सूची समझ धन्यवाद

f x=unlines[[1..n]>>"*"|n<-[1..x]]

पुराना संस्करण:

f 0=""
f n=f(n-1)++([1..n]>>"*")++"\n"

वैकल्पिक संस्करण:

g n=([1..n]>>"*")++"\n"
f n=[1..n]>>=g
— क्रेग रॉय
स्रोत
आप एक बाइट को बचाने के ([1..n]>>"*")बजाय उपयोग कर सकते हैं replicate n'*'। मैं भी केवल 39 बाइट्स गिनता हूं।
— लकोनी
अच्छा वैकल्पिक संस्करण! हालाँकि मुझे लगता है कि बाइट की गिनती अभी भी एक से है और 38 होनी चाहिए। (उदाहरण के लिए यहां देखें ) समस्या नई हो सकती है f 0=""जिसके बाद एक बाइट के रूप में गिना जाता है, लेकिन कुछ पाठ संपादकों में दो बाइट्स / वर्ण के रूप में दिखाया गया है।
— लकोनी
धन्यवाद! अब मैं देख रहा हूं कि जब मैं पात्रों की गिनती कर रहा था, तो मैं शुरू में एक नई रूपरेखा जोड़ रहा था। फिर से वह गलती नहीं करेंगे!
— क्रेग रॉय
2
आप सूची समझ पर स्विच कर सकते हैं f x=unlines[[1..n]>>"*"|n<-[1..x]]:।
— nimi
6

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

VQ*\*hN

@ETHproductions के लिए एक बाइट धन्यवाद बंद करके इसे ऑनलाइन आज़माएं

@ PIetu1998 की तकनीक का उपयोग करना

6, बाइट्स

j*L*\*S
— डिग्निसिमस - स्पैमी
स्रोत
अच्छा जवाब! आप बदल सकते हैं "*"के साथ \*।
— ETHproductions
@ETHproductions मैं इसके बारे में कभी नहीं जानता था, धन्यवाद!
— डिग्निसिमस - स्पैमी
आप नक्शे के साथ एक और बाइट निकाल सकते हैं। j*L\*S(inclu Sive रेंज, प्रत्येक *Lको "*" से गुणा करें \*, jन्यूलाइन द्वारा oin) पाइथ अंत में एक अंतर्निहित क्यू सम्मिलित करता है।
— पुरकाकूदरी
jm*\*h6 बाइट्स भी है।
— hakr14
6

2sable , 24 11 बाइट्स

>G')Ç>çJN×,

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

और किसी भी तारांकन का कोई संकेत नहीं! @Emigna के लिए 24 से 11 धन्यवाद दिया गया ।

स्पष्टीकरण:

>G')Ç>çJN×,
>            Push input+1
 G           For N in range (1,input+1)
  ')Ç>çJ     Push '*' by getting ascii code for ')' and adding 1
        Nx,  Print '*' repeated N times
— जेनो रैकिन अशर
स्रोत
1
कुछ सुझाव। õVYIकिसी भी तरह से आपके कोड को प्रभावित नहीं करता है और इसे हटाया जा सकता है। 1+के रूप में ही है >। यदि आप लूप में तारांकन चिह्न बनाते हैं तो आप निकाल भी सकते हैं UX। ×आंतरिक लूप के बजाय का उपयोग करना और भी अधिक बाइट बचाता है। परिवर्तन विधि के बिना आप इसे 11 बाइट्स या उससे कम पर प्राप्त कर सकते हैं।
— इमिग्ना
1
अच्छा! मैं जल्द ही संपादित करूँगा
— जेनो रैक्लिन अशर
क्या आप एक स्पष्टीकरण जोड़ सकते हैं?
— बफ़र ओवर पढ़ें
अद्भुत कोड, इनाम मिलने पर बधाई! समुदाय बॉट केवल 25 से सम्मानित किया गया लगता है न कि मूल 50 मुझे लगता है क्योंकि मैं समय सीमा से पहले इनाम देने के लिए भूल गया, इसके लिए क्षमा करें।
— बफर ओवर पढ़ें
1
इसके बारे में चिंता मत करो। बस 100-प्रतिनिधि के निशान तक पहुंचने की खुशी है। @TheBitByte
— Geno Racklin आशेर
6

ब्रेन-फ्लैक 75 बाइट्स

के लिए +3 शामिल है -A 

{(({})[()]<{({}[()]<(((((()()()){}()){})){}{})>)}{}((()()()()()){})>)}{}

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

स्पष्टीकरण:

{(({})[()]<                                                        >)}
#reduce the top element by one until it is 0 after doing the following
#Push this element back on to act as a counter for the next step.
#(counts down from input to 0 we'll call this counter)

           {({}[()]<                          >)}
           #reduce the top element by one until it is 0 after doing the following
           #(counts down from counter to 0)

                    (((((()()()){}()){})){}{})  
                    #push 42 (the ASCII code for *)

                                                 {}
                                                 #pop the counter used to push
                                                 #the right number of *s

                                                   ((()()()()()){})
                                                   #push a 10 (newline)

                                                                      {}
                                                                      #pop the null byte
— रिले
स्रोत
इसमें आउटपुट में एक शून्य बाइट शामिल है? मुझे नहीं लगता कि इसकी अनुमति है ...
— विनाशकारी नींबू
नहींं, मेरा मतलब है एक शून्य बाइट
— विनाशकारी नींबू
@DestructibleWatermelon हाँ, मुझे लगता है कि यह करता है। हालांकि आसान तय। धन्यवाद।
— रिले
6

दिल्लोग एपीएल , 8 बाइट्स

↑'*'⍴⍨¨⍳

↑ सूची से मिलकर बनता है

'*' डोर "*"

⍴⍨ द्वारा फिर से तैयार

¨ की प्रत्येक

⍳ पूर्णांक 1 तर्क के माध्यम से।

TryAPL ऑनलाइन!

— एडम
स्रोत
मुझे 8 बाइट्स लगती हैं।
— आउटगोल्फर
1
अगर ⌸एक भी बाइट हो सकती है:(,⍕⊢)⌸⍳
— ngn
@ng वह बहुत चालाक है! इसे अपनी मर्जी से पोस्ट करें। आप वास्तव में इसे एक बाइट के रूप में गिन सकते हैं जिसे आप लिखते हैं 7 bytes<sup>SBCS</sup>।
— आदम
5

वी , 8 बाइट्स

Àé*hòlÄx

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

— DJMcMayhem
स्रोत
ओह, हाँ Àé hòlÄ!
— जोनाथन एलन
2
@JonathanAllan अरे, कम से कम यह जेली से अधिक पठनीय है। (मेरे लिए);)
— DJMcMayhem
जेली का कोड पृष्ठ है, बहुत अच्छी तरह से संगठित मुझे लगता है। हाल ही में लिन द्वारा बनाए गए विकी के एटम्स पेज के ओवरहाल की जाँच करें ।
— जोनाथन एलन
3
@JonathanAllan हाँ, मुझे विश्वास है। यह ऐसा नहीं लग सकता है, लेकिन वी के mnemonics अच्छी तरह से व्यवस्थित होने के कारण आप उन्हें टाइप करने के लिए उपयोग करते हैं। तो विम-की लिंगो में मेरा समाधान है <M-@><M-i>*h<M-r>l<M-D>x(मी का अर्थ है मेटा, जिसका अर्थ है अल्ट)। उन सभी के लिए बहुत अच्छा mnemonics है जो कमांड करता है।
— DJMcMayhem
5

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

f=x=>x?f(x-1)+`
`+'*'.repeat(x):''
— Huntro
स्रोत
5

पर्ल 6 , 23 बाइट्स

{.put for [\~] '*'xx$_}

(यदि आउटपुट को नई लाइनों के बिना "लाइनों" की एक सूची बनने की अनुमति दी .put for जाए)

स्पष्टीकरण:

# bare block lambda with implicit parameter ｢$_｣
{
  .put            # print with trailing newline
    for           # for every one of the following
      [\~]        # produce using concatenation operator
        '*' xx $_ # list repeat '*' by the input
}

( produceयदि आप क्या [\~] ...कर रहे हैं यह नहीं समझते हैं तो प्रलेखन देखें )

— ब्रैड गिल्बर्ट b2gills
स्रोत
5

पर्ल 5, 22 20 बाइट्स

say"*"x$_ for 1..pop

इसे -Eपाने के लिए स्विच के साथ चलाएँ say।

$ perl -E 'say"*"x$_ for 1..pop' 5
*
**
***
****
*****

एक पूर्ण कार्यक्रम के रूप में यह इस तरह दिखेगा:

use strict;
use feature 'say';

# get the argument
my $limit = pop @ARGV;

foreach my $i (1 .. $limit) { 
    say "*" x $i; 
}
— simbabque
स्रोत
यदि मुझे कमांड लाइन स्विच के लिए अतिरिक्त बाइट्स की आवश्यकता है तो निश्चित नहीं।
— सिम्बैब
मेरा मानना ​​है कि -Eध्वज 1 अतिरिक्त बाइट के रूप में गिना जाता है।
— ETHproductions
पैरामीटर के बजाय इनपुट के रूप में संख्या लेने के बारे में क्या? perl -E 'say"*"x$_ for 1..<>' <<< 5
— मैनटवर्क
@manatwork हाँ जो काम करेगा। मैं हालांकि गिनती में अच्छा नहीं हूं। यकीन नहीं होता है कि अनुमति दी है।
— सिम्बैब
1
-Eनि: शुल्क है (जैसा कि यह बदलता है -eजिसकी वैसे भी आवश्यकता होगी)। यदि आप वास्तव में कमांड लाइन से नंबर लेना चाहते हैं (क्यों नहीं, भले ही <>1 बाइट छोटी हो, और अनुमति दी गई हो), आपको popइसके बजाय shift(2 बाइट्स छोटे) का उपयोग करना चाहिए ! पीपीसीजी पर आपका स्वागत है, आपको गोल्फ देखकर खुशी होगी!
— दादा
5

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

-4 बाइट्स @Ton Hospel और समाधान के अपने काम के लिए धन्यवाद !

eval"s//*/;say;"x<>

चलाने के लिए स्वतंत्र -E(या -M5.010) ध्वज चाहिए। इनपुट से एक नंबर लेता है:

perl -E 'eval"s//*/;say;"x<>' <<< "5"
— बापू
स्रोत
1
आप समाधान evalके समान लंबाई for( <>इसके बजाय का उपयोग करके pop) कर सकते हैंeval"s//*/;say;"x<>
— टन हास्पेल
@TonHotel Ineed, अच्छा! धन्यवाद!
— दादा
5

जे, 11 8 बाइट्स

मीलों तक 3 बाइट्स बचाए!

]\@#&'*'

यहाँ एक अपघटन है:

(]\@#&'*') x
x (]\@#) '*'
]\ (x # '*')

अब, यह आखिरी " ]\स्ट्रिंग की xप्रतियों से युक्त उपसर्ग ( ) " के रूप में पढ़ता है '*'। का निरीक्षण करें:

   5 ]\@# '*'
*
**
***
****
*****
   ]\ 5# '*'
*
**
***
****
*****
   ]\ 5 # '*'
*
**
***
****
*****
   ]\@#&'*' 5
*
**
***
****
*****

परीक्षण का मामला

   f =: ]\@#&'*'
   f 3
*
**
***
   f 5
*
**
***
****
*****
   f 1
*
   f 2
*
**
   f &. > ;/1+i.10
+-+--+---+----+-----+------+-------+--------+---------+----------+
|*|* |*  |*   |*    |*     |*      |*       |*        |*         |
| |**|** |**  |**   |**    |**     |**      |**       |**        |
| |  |***|*** |***  |***   |***    |***     |***      |***       |
| |  |   |****|**** |****  |****   |****    |****     |****      |
| |  |   |    |*****|***** |*****  |*****   |*****    |*****     |
| |  |   |    |     |******|****** |******  |******   |******    |
| |  |   |    |     |      |*******|******* |*******  |*******   |
| |  |   |    |     |      |       |********|******** |********  |
| |  |   |    |     |      |       |        |*********|********* |
| |  |   |    |     |      |       |        |         |**********|
+-+--+---+----+-----+------+-------+--------+---------+----------+

पुराने, 11-बाइट समाधान

'*'#~"+1+i.

यह बराबर है

'*' #~"0 1 + i.

1 + i.सीमा है [1, x]। फिर, '*' #~"0इस श्रेणी आकृतियों (तत्व) की प्रतियों पर लागू किया जाता है '*'।

बोनस कार्यक्रम:

[:#&'*'\#&1

यह एक छाया हुआ कांटा #&'*'\है #&1जो इनपुट के परिणाम पर लागू होता है । #&1की एक सरणी देता xहैं, और #&'*'\आकार '*'इस सरणी की उपसर्गों को।

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

   f1 =: '*'#~"+1+i.
   f2 =: [:#&'*'\#&1
   f1 1
*
   f2 2
*
**
   f1 3
*
**
***
   f2 4
*
**
***
****
   f2 5
*
**
***
****
*****
   f1 5
*
**
***
****
*****
   (f1;f2)3
+---+---+
|*  |*  |
|** |** |
|***|***|
+---+---+
   f1;f2
f1 ; f2
   (f1;f2)5
+-----+-----+
|*    |*    |
|**   |**   |
|***  |***  |
|**** |**** |
|*****|*****|
+-----+-----+
   (f1;f2)10
+----------+----------+
|*         |*         |
|**        |**        |
|***       |***       |
|****      |****      |
|*****     |*****     |
|******    |******    |
|*******   |*******   |
|********  |********  |
|********* |********* |
|**********|**********|
+----------+----------+
— कोनोर ओ ब्रायन
स्रोत
आप 8 बाइट्स nके '*'लिए कॉपियों की स्ट्रिंग के उपसर्गों का भी उपयोग कर सकते हैं]\@#&'*'
— मील
@ मीलों: और एक अन्य 9 बाइट संस्करण:'*'"0\@i.
— जोनाह
5

विम, 22 , 18 कीस्ट्रोक्स

O <esc>J:h r<cr>lyEZZ<C-v>{@"

@Udioica के लिए बहुत बड़ा श्रेय जब तक कि मैंने इस पर विस्तार नहीं किया। इस जवाब में इनाम जीतने की उम्मीद में कोई तारांकन नहीं है।

स्पष्टीकरण:

बाकी प्रोग्राम से पहले इनपुट टाइप किया जाता है। Udioica इस भयानक चाल के साथ आया था। टंकण <n>O <esc>एक रिक्त स्थान और एक खाली रेखा का पिरामिड बनाएगा, जब तक आपने :set autoindentसक्षम किया है। यह विकल्प विम 8 और नियोविम में डिफ़ॉल्ट रूप से आता है, हालांकि पुराने संस्करण नहीं हैं। चूंकि यह एक अतिरिक्त रेखा भी बनाता है, इसलिए हम Jअगले एक के साथ इस लाइन में शामिल होने के लिए उपयोग करते हैं, जो प्रभावी रूप से हमारे नीचे की रेखा को हटा देता है।

अब इस बिंदु पर, हमें इन सभी स्थानों को तारांकन के साथ बदलने की आवश्यकता है। यदि मैं अपने कोड में तारांकन का उपयोग करने के बारे में चिंतित नहीं था, तो मैं पूरी तरह से पूरी तरह से उस चीज़ <C-v>{और प्रकार का चयन करूंगा r*, जो चयन के प्रत्येक चरित्र को तारांकन के साथ बदल देता है। लेकिन मैं ऐसा नहीं कर सकता।

इसलिए हम मदद पृष्ठों को खोलते हैं :h r। इसके बारे में दिलचस्प बात यह है कि विम-विंडो में, यह पृष्ठ इस प्रकार प्रदर्शित होता है:

                            r
r{char}         Replace the character under the cursor with {char}.
                ...

पहले 'r' पर कर्सर के साथ। हालाँकि, फ़ाइल में वास्तव में यह पाठ शामिल है:

                            *r*
r{char}         Replace the character under the cursor with {char}.
                ...

बहुत सुविधाजनक है। इसलिए हम एक अक्षर से आगे बढ़ते हैं l, और पाठ r*को yE(इस शब्द के n [e] एन को [y] ak के साथ ) भरते हैं।

इस बफ़र को बंद करने के लिए, हम किसी फ़ाइल को सहेजने के लिए शॉर्टकट का उपयोग करते हैं ZZ। अब, हम नेत्रहीन रूप से हमारे रिक्त स्थान का चयन करते हैं, और yanked पाठ को चलाते हैं जैसे कि हमने इसे करके टाइप किया था @"। यह काम करता है क्योंकि "@" निम्नलिखित रजिस्टर को vim-keystrokes के रूप में चलाता है, और "yanking के लिए डिफ़ॉल्ट रजिस्टर है।

— DJMcMayhem
स्रोत
यह समझाने के लिए कि यह कैसे काम करता है?
— corvus_192
@ corvus_192 मैंने एक अधिक व्यापक स्पष्टीकरण जोड़ा है, साथ ही साथ कुछ और गोल्फिंग भी की है।
— DJMcMayhem
क्या डेटा फ़ाइल का आकार बाइट संख्या में नहीं जोड़ा जाना चाहिए?
— '
@ क्या मदद फ़ाइल का आकार? नहीं, क्योंकि यह फ़ाइल विम के साथ स्थापित है, और एक डिफ़ॉल्ट विशेषता है।
— DJMcMayhem
5

सी, 47 46 45 43 बाइट्स

कमांड लाइन से इनपुट लेता है

f(n){for(n&&f(n-1);~n;putchar(n--?42:10));}

मूल रूप से यदि n, n-1 पर 0 पुनरावृत्ति नहीं है। पुनरावर्तन के शीर्ष पर जहां n 0 है, यह सिर्फ एक नई रेखा को प्रिंट करता है, लूप के लिए समाप्त होता है जब n -1 या ~ n शून्य होता है, अन्यथा यह ASCII 42 को प्रिंट करता है जो '*' है। इसे आइडोन पर आज़माएं

Iostream को शामिल करने के लिए C ++ 58 बाइट्स + 19 77 है

#include<iostream>
int f(int n){for(n&&f(n-1);~n;std::cout<<(n--?"*":"\n"));}


main(c,v)char**v;
{
    f(atoi(v[1]));
}


a.exe 3
*
**
***
— cleblanc
स्रोत
मेरे लिए के साथ काम करने लगता है &&: n?f(n-1):0→ n&&f(n-1)।
— मैनेटवर्क
@manatwork धन्यवाद कली। एक और बाइट बचत
— cleblanc
Ideone में 2 त्रिभुज शो के प्रिंट के अंत में एक '\ n' अधिक है: * ** *** * ** *** **** ***** मैं कहता हूं केस 0 केस खत्म होने का मामला पुनर्मिलन, एक \ n और प्रिंट करें
— RosLuP
@RosLup हाँ यह एक प्रमुख और एक अनुगामी न्यूलाइन छाप रहा है। मुझे लगता है कि ओपी ने कहा कि उनकी टिप्पणियों में ठीक था।
— क्लेब्लांक
4

रेटिना , 14 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

.+
$**
.
$`$&¶

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

व्याख्या

.+
$**

तारांकन Nमें इनपुट चालू करें N।

.
$`$&¶

प्रत्येक तारांकन को हर चीज के साथ बदलें और उस तारांकन (यह है $`$&) और एक लाइनफीड (यह )।

— मार्टिन एंडर
स्रोत
4

क्यूबिक्स , 22 बाइट्स

?(.;I:^;/-.@o;(!\>'*oN

इसे ऑनलाइन टेस्ट करें!एक अनुगामी न्यूलाइन आउटपुट करता है।

पहले मुझे यकीन नहीं था कि मैं इसे 2-क्यूब पर फिट कर सकता हूं, लेकिन अंत में इसने ठीक काम किया:

    ? (
    . ;
I : ^ ; / - . @
o ; ( ! \ > ' *
    o N
    . .

जब मेरे पास समय होगा, मैं एक स्पष्टीकरण जोड़ूंगा, उम्मीद है कि आज बाद में।

— ETHproductions
स्रोत
कभी भी स्पष्टीकरण? : पी
— फ्लिप डिकैक
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.