25

एक संख्या को देखते हुए N, एक NxN समकोण त्रिभुज का उत्पादन करता है, जहाँ प्रत्येक पंक्ति iसंख्याओं से भरी होती है i।

उदाहरण

n = 0

(उत्पादन नही)

n = 4

n = 10

1
1 2
1 2 3
.
.
.
1 2 3 4 5 6 7 8 9 10

(कोई संरेखण की आवश्यकता)

एन = एन

1
1 2
1 2 3
.
.
.
1 2 3 4 .... N

प्रत्येक पंक्ति के अंत में कोई अनुगामी स्थान नहीं है।

कम से कम बाइट्स जीतता है, और मानक खामियों की अनुमति नहीं है।

code-golf number

— तन WS
स्रोत

क्या आउटपुट संख्याओं की नेस्टेड सूची हो सकती है?

— देखिए

N = 0, और n> 9 के लिए क्या व्यवहार होना चाहिए?

— freekvd

@Sieg ज़रूर, जब तक आउटपुट सही है।

— टैन डब्लूएस

@freekvd 0 के लिए कोई आउटपुट नहीं है, n> 9 के लिए कोई विशेष प्रारूपण आवश्यक नहीं है

— Tan WS

आह, तुमने मेरी अधीनता तोड़ दी। फिक्सिंग ASAP

— 5

17

जो , 5 3 बाइट्स ( `-t`झंडे के लिए +2 या +3 )

खैर, जाहिरा तौर पर मैं जो की पूरी क्षमता का उपयोग नहीं किया। यह संभव था जब मैंने पहली बार यह पोस्ट किया था।

\AR

यहाँ, R0 से n तक की रेंज देता है, एक्सक्लूसिव। फिर \Aइसका क्रमिक उपसर्ग लेता है ( Aपहचान कार्य है)। उदाहरण:

-tध्वज के साथ (ध्यान दें: यह अब ध्वज के बिना भी मानक आउटपुट है):

इसके बिना:

   \AR5
[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]
   (\AR)5
[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]
   \AR2
[[0], [0, 1]]
   \AR1
[[0]]
   \AR0
[]

नियम थोड़े बदले गए। मेरे पुराने कोड ने N = 0 के साथ सही व्यवहार नहीं किया। इसके अलावा, अब आउटपुट सिर्फ एक नेस्टेड सूची हो -tसकती है , इसलिए इसे गिराया जा सकता है।

1R1+R

अब, Rn0 से n तक की रेंज देता है, एक्सक्लूसिव। यदि 0 दिया गया है, तो यह खाली सूची देता है। 1+उस श्रेणी के प्रत्येक तत्व में 1 जोड़ता है। 1R1 से लेकर x तक मानों को मैप करता है। खाली लीट, जब मैप किया जाता है, तो खाली सूची लौटाएं।

उदाहरण आउटपुट:

   1R1+R0
[]
   1R1+R5
[[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]

अद्यतन: मैंने अभी कुछ देखा। फ़ंक्शन स्वचालित रूप से 0 तत्वों को रैंक करने के लिए मैप करता है। निम्न उदाहरण -tध्वज के साथ चलाया जाता है ।

   1R1+R3 5 8
1
1 2
1 2 3

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8

पुराना: 5 बाइट्स ( -tध्वज के साथ )

1R1R

यह एक अनाम फ़ंक्शन है जो एक संख्या में लेता है, 1 से एन तक एक सूची बनाता है ( 1Rn) और उन मानों को पूर्ववर्ती सीमा तक मैप करता है, जो रेंज 1 से एन के प्रत्येक आइटम के लिए 1 से x तक की सीमा देता है।

-tझंडा एक जे की तरह तालिका के रूप में उत्पादन देता है।

नोट: भाषा बहुत नई है और पूर्ण नहीं है, लेकिन इस चुनौती से पहले नवीनतम संस्करण जारी किया गया था।

— seequ
स्रोत

4

तो जम्मू सरणी आधारित चुनौतियों पर एक फायदा होने के लिए पर्याप्त नहीं था? : D

— ऑप्टिमाइज़र

4

@ ऑप्टिमाइज़र ऑप्टिमाइज़िंग महत्वपूर्ण है।

— देखिए 5

4

अचानक, मेरा सबसे अधिक वोट दिया गया जवाब है, जिस पर मैंने सबसे कम समय बिताया है। अन्याय।

— at

1

मुझे लगता है कि जो आपका औसत नहीं है ...

— जस्टिन

10

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

f=lambda n:n and[f(n-1),print(*range(1,n+1))]

दुष्प्रभाव के लिए हुर्रे।

— Sp3000
स्रोत

2

नेस्टेड कुछ नहीं। अब वह मुड़ी हुई है।

— देखिए

यह एक गलत चाल है: रिवर्स ऑर्डर में एस printको निष्पादित करने के लिए फ़ंक्शन को डालने से पहले print।

— xnor

8

एपीएल, ५

⍪⍳¨⍳⎕

एक वेक्टर बनाता है 1..n और प्रत्येक तत्व के लिए एक और ऐसा वेक्टर।

तब Then सभी वैक्टर में से एक कॉलम बनाता है। यह समस्या के साथ रिक्त स्थान से बचा जाता है।

इसे tryapl.org पर देखें

पुराना समाधान:

{⎕←⍳⍵}¨⍳⎕

एक वेक्टर बनाता है 1..n

{← for ⍳⍵} एक ऐसा फंक्शन है जो प्रत्येक के लिए आउटपुट (() एलिमेंट को वेक्टर करता है। 1. एक अलग लाइन पर

यह दुर्भाग्य से tryapl.org पर नहीं देखा जा सकता है, क्योंकि ←। वहाँ काम नहीं करता है।

— मोरिस ज़ुक्का
स्रोत

किसी भी पंक्ति में कोई अनुगामी स्थान नहीं होना चाहिए।

— रैंडम

आह धन्यवाद, मैं उस एक को याद किया। जल्द ही ठीक हो जाएगा

— मोरिस ज़ुका

मुझे पता था कि एपीएल एक समाधान होगा

— कॉनर ओ'ब्रायन

हे भगवान, मेरी आँखें क्या देख रही हैं

— Codefun64

6

जे, 27 बाइट्स

J गैर-सरणी संख्यात्मक आउटपुट के साथ अच्छा नहीं है। यह फ़ंक्शन संख्याओं से एक ठीक से स्वरूपित स्ट्रिंग बनाता है।

   ;@(<@,&LF@":@:>:@:i.@>:@i.)

   (;@(<@,&LF@":@:>:@:i.@>:@i.)) 4
1
1 2
1 2 3
1 2 3 4

इसे यहाँ ऑनलाइन आज़माएँ।

— randomra
स्रोत

तुम भी ]\@i.प्राप्त करने के लिए इस्तेमाल कर सकते हैं;@(<@,&LF@":@:>:@:]\@i.)

— 21'15 बजे

6

PHP, 53 बाइट्स

संपादित 2: इस्माइल मिगुएल ने एक फ़ंक्शन को परिभाषित करने के बजाय इनपुट से पढ़ने का सुझाव दिया, इसलिए स्कोर अब PHP के लिए 53 बाइट्स है:

for($a=1;@$i++<$n=$argv[1];$a.=" ".($i+print"$a\n"));

और एक बार फिर, यह सुधार किया जा सकता है यदि PHP त्रुटियों को अनदेखा करने के लिए कॉन्फ़िगर किया गया है (52 बाइट्स):

for($a=1;$i++<$n=$argv[1];$a.=" ".($i+print"$a\n"));
for($a=1;$i++<$n=$_GET[n];$a.=" ".($i+print"$a\n"));

संपादित करें: ऑस्टिन ने टिप्पणियों में एक 60 बाइट्स संस्करण का सुझाव दिया:

function f($n){for($a=1;@$i++<$n;$a.=" ".($i+print"$a\n"));}

अगर हम PHP त्रुटियों (59 बाइट्स) को प्रदर्शित नहीं करते हैं तो सुधार किया जा सकता है:

function f($n){for($a=1;$i++<$n;$a.=" ".($i+print"$a\n"));}

$aअगली पंक्ति को संग्रहीत करता है जिसे मुद्रित किया जाएगा, और हर बार यह एक स्थान मुद्रित किया जाता है और अगली संख्या ( printहमेशा रिटर्न 1) को इसे संक्षिप्त कर दिया जाता है।

पुनरावर्ती कार्य (65 बाइट्स):

function f($n){$n>1&&f($n-1);echo implode(' ',range(1,$n))."\n";}
function f($n){$n>1&&f($n-1);for(;@$i++<$n;)echo$i,' ';echo"\n";}   // Using @ to hide notices.

छोटे पुनरावर्ती कार्य, त्रुटि रिपोर्टिंग अक्षम (64 बाइट्स) के साथ:

function f($n){$n>1&&f($n-1);for(;$i++<$n;)echo$i,' ';echo"\n";}

यहां तक कि कम पुनरावर्ती कार्य, त्रुटि रिपोर्टिंग अक्षम होने और वास्तविक आउटपुट से पहले एक खाली लाइन (62 बाइट्स) के साथ:

function f($n){$n&&f($n-1);for(;$i++<$n;)echo$i,' ';echo"\n";}

सिर्फ मनोरंजन के लिए, गैर-पुनरावर्ती fucntions:

function f($n){for($i=0;$i<$n;print implode(' ',range(1,++$i))."\n");}    // 70 bytes
function f($n){for(;@$i<$n;print implode(' ',range(1,@++$i))."\n");}      // 68 bytes, hiding notices.
function f($n){for(;$i<$n;print implode(' ',range(1,++$i))."\n");}        // 66 bytes, error reporting disabled.

— बेनोइट एसनार्ड
स्रोत

2

45 बाइट्स:for($a=1;@$i<$n;$a.=" ".(@++$i+print"$a\n"));

— ऑस्टिन

@ ऑस्टिन: मैंने एक टिप्पणी में पढ़ा है कि कोड या तो इनपुट, या एक फ़ंक्शन से पूरा कार्यक्रम पढ़ना चाहिए। बहुत अच्छी चाल, इसे थोड़ा / बाइट द्वारा सुधारा जा सकता है: for($a=1;@$i++<$n;$a.=" ".($i+print"$a\n"));(44 बाइट्स)

— बेनोइट एस्नर्ड

आह ठीक है, तो मुझे लगता है कि आप function f($n){for($a=1;@$i++<$n;$a.=" ".($i+print"$a\n"));}60 बाइट्स करेंगे।

— ऑस्टिन

वास्तव में। क्या आप ठीक हैं यदि मैं अपना उत्तर आपके समाधान को जोड़ने के लिए संपादित करता हूं?

— बेनोइट एस्नर्ड

1

for($a=1;$i++<$n=$_GET[n];$a.=" ".($i+print"$a\n"));-> यह कोशिश करें (पूर्ण कोड, nसंख्या के साथ यूआरएल पैरामीटर का उपयोग करके )

— Ismael Miguel

5

CJam, 13 12 बाइट्स

ri{),:)S*N}/

यह कैसे काम करता है :

ri{       }/     "Run the block input number of times with iteration index from 0 to N-1";
   )             "Increment the iteration index (making it 1 to N)";
    ,            "Get an array of 0 to iteration index";
     :)          "Increment each of the above array members by 1";
       S*        "Join all above array numbers with space";
         N       "Add a new line. After all iterations, things are automatically printed";

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

4

अजगर, 9 बाइट्स

VQjdr1hhN

वास्तव में सोचा था कि यह कम किया जा सकता है, लेकिन ऐसा नहीं लगता है।

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

            Q = input()
VQ          For N in [0, 1, ..., Q-1]:
    r1hhN       create list [1, ..., N+1+1-1]
  jd            print joined with spaces

— Jakube
स्रोत

1

एक वैकल्पिक 9 VQaYhNjdY:। यदि केवल aसूची वापस आ जाती है, तो कुछ ऐसा VQjdaYhNहोगा जैसे

— Sp3000

2

aसंक्षेप में संलग्न सूची वापस करने के लिए उपयोग किया जाता है।

— ऑप्टिमाइज़र

मैं अजगर से परिचित नहीं हूं, तो क्या आप इसका विस्तार कर सकते हैं N+1+1-1?

— २०

1

@ साइग rपायथन-रेंज फ़ंक्शन है, इसलिए -1 ( r1Nसूची बनाता है [1, 2, ..., N-1])। लेकिन पाश के Nth पुनरावृत्ति में, मुझे सूची चाहिए [1, 2, ..., N+1], इसलिए मुझे इसमें जोड़ना 2होगा N। r1hhNसीधे अनुवाद करता है range(1, N+1+1)। एक और संभावना होगी r1+N2( range(1, N+2))।

— जकुबे

या यहां तक कि mhdhN, लेकिन यह एक पूर्ण भिन्न दृष्टिकोण है।

— जकुबे

4

जावास्क्रिप्ट (ईएस 6) 49 52

इस तरह के एक सरल कार्य, मुझे आश्चर्य है कि अगर इसे जेएस में छोटा किया जा सकता है (अद्यतन: हाँ, पुनरावर्तन का उपयोग करके)

पुनरावर्ती ४ ९

f=n=>alert((r=w=>n-i++?w+'\n'+r(w+' '+i):w)(i=1))

इतरैव ५२

f=n=>{for(o=r=i=1;i++<n;o+='\n'+r)r+=' '+i;alert(o)}

— edc65
स्रोत

मैं यह कहां से परख सकता हूं? मैं किसी भी ES6 खेल के मैदान को ढूंढ नहीं सकता, जो इसे स्वीकार करता है

— क्रिस्टोफ़र साल्-स्टॉरगार्ड

@ KristofferSall-Storgaard फ़ायरफ़ॉक्स ES6 को डिफ़ॉल्ट होने का समर्थन करता है। इसलिए फ़ायरफ़ॉक्स कंसोल।

— ऑप्टिमाइज़र

4

जावा, 85 84 बाइट्स

यह जावा में आश्चर्यजनक रूप से कम है।

void a(int a){String b="";for(int c=0;c++<a;System.out.println(b+=(c>1?" ":"")+c));}

इंडेंट:

void a(int a){
    String b="";
    for(int c=0;
        c++<a;
        System.out.println(
                b+=(c>1?" ":"")+c
        ));
}

Bigtoes / Geobits के लिए 1 बाइट धन्यवाद

— नंबर एक
स्रोत

आप को ले जाकर एक को बचा सकता है b+=...में println(b+=...)।

— जोबिट्स

3

प्रस्तावना - ११ ९

h(N):-setof(X,(between(1,N,K),setof(Y,between(1,K,Y),X)),[L]),k(L),nl,fail.
k([A|B]):-write(A),(B=[];write(" "),k(B)).

— Οurous
स्रोत

3

अजगर 2 - 62 54 65 बाइट्स

def f(n):
 for x in range(n):print' '.join(map(str,range(1,x+2)))

— pepp
स्रोत

nकार्यक्रम को इनपुट के रूप में नंबर दिया जाना चाहिए, एक चर में आरंभीकृत नहीं।

— जरगब

संकेत के लिए धन्यवाद। उस पर यकीन नहीं था।

— pepp

2

क्षमा करें, मुझे स्पष्ट होना चाहिए था। मेरा मतलब यह है कि आपको वास्तव Nमें ऐसा करने N=input()या कुछ इसी तरह से परिभाषित करना चाहिए , ताकि आपका कार्यक्रम इस तरह चलाया जा सके। यहाँ विषय पर एक मेटा चर्चा है।

— जरगब

तो यह सही होगा, है ना?

— pepp

अब अच्छा लग रहा है!

— ज़र्गब

3

जे, 9 वर्ण

एक मौन के रूप में, संन्यासी क्रिया।

[:":\1+i.

i. y- से संख्या 0के लिए y - 1।
1 + i. y- से संख्या 1के लिए y।
": y- वेक्टर yको एक स्ट्रिंग के रूप में दर्शाया गया है।
":\ y- yएक स्ट्रिंग के रूप में प्रतिनिधित्व के प्रत्येक उपसर्ग ।
":\ 1 + i. y- वर्णों के एक मैट्रिक्स के रूप में प्रतिनिधित्व 1करने के लिए संख्याओं के प्रत्येक उपसर्ग y।

— FUZxxl
स्रोत

अब वह काफी स्मार्ट है। +1

— सीरी

यह अधिक J-esque है, लेकिन क्या यह नियम का उल्लंघन नहीं करता है कि प्रत्येक पंक्ति में कोई अनुगामी स्थान नहीं है?

— मील

@ मीलों वास्तव में यह करता है! और कुछ भी बहुत जटिल होगा।

— 14:19 बजे फ़ूजएक्सएक्सएल

3

> <> (मछली) , 40 37 + 3 = 40 बाइट्स

&1>:&:&)?;1\
(?v:n" "o1+>}:{:@
ao\~1+

एक बार फिर,> <> दूसरे नंबर की प्रिंटिंग एक्सरसाइज में शालीनतापूर्वक अच्छी तरह से करता है। -vइनपुट के लिए ध्वज के साथ चलाएँ , उदा

py -3 fish.py -v 4

व्याख्या

&               Put n in register
1               Push 1 (call this "i")

[outer loop]

:&:&)?          If i > n...
;                 Halt
1                 Else push 1 (call this "j")

[inner loop]

}:{:@(?         If j > i...
~1+ao             Pop j, print newline, increment i and go to start of outer loop
:n" "o1+          Else print j, print a space, increment j and go to start of inner loop

— Sp3000
स्रोत

3

सी (कोई छोरों के साथ, हाँ!) - 72 बाइट्स

b(n,c){if(n){b(n-1,32);printf("%d%c",n,c);}}r(n){if(n){r(n-1);b(n,10);}}

यह एक फ़ंक्शन बनाता है r(n)जिसका उपयोग इस तरह किया जा सकता है:

main(){ r(5); }

इसे एक्शन में देखें, यहाँ tutorialspoint.com पर

इसके लिए बहुत ही आसानी से समझाई जाने वाली कुछ ट्रिक्स की जरूरत होती है। मुझे लगता है कि इसमें बहुत सुधार किया जा सकता है।

— A. ब्रेस्ट
स्रोत

1

वास्तव में यह Actually५ बाइट्स है, .४ नहीं। हालांकि, आप इसे b(n,c){if(n){b(n-1,32);printf("%d%c",n,c);}}r(n){if(n){r(n-1);b(n,10);}}

— and२ बाइट्स के

1

बहुत अच्छी चाल, धन्यवाद!

— ए। ब्रेस्ट

धन्यवाद! मैंने आपको C श्रेणी में शामिल करने की पूरी कोशिश की, लेकिन मैं कुछ कम नहीं कर सका! इसलिए मैंने आपकी जगह छोटा करने का फैसला किया।

— फेटलस्लीप

64 बाइट्स b(n,c){n&&b(n-1,32)^printf("%d%c",n,c);}r(n){n&&r(n-1)^b(n,10);} वैंडबॉक्स

— o79y

2

अजगर 2 - 72

>>> def p(N):print'\n'.join(' '.join(map(str,range(1,i+2)))for i in range(N))
... 
>>> p(5)
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

— Kasramvd
स्रोत

इस साइट पर जवाब के लिए, आपको एक पूरा कार्यक्रम या फ़ंक्शन लिखना चाहिए। और आपको परिणाम को स्टैडआउट में प्रिंट करना चाहिए, या उन्हें एक फ़ंक्शन से वापस करना चाहिए। एन को इनपुट से पढ़ा जाना चाहिए या फ़ंक्शन पैरामीटर के रूप में लिया जाना चाहिए, न कि एक चर के रूप में पूर्वनिर्धारित।

— jimmy23013

@ user23013 ठीक, तय!

— कासमरवद

फ़ंक्शन परिभाषा को बाइट काउंट में शामिल करने की आवश्यकता है, इसलिए मुझे नहीं लगता कि यह 61 है। यह फ़ंक्शन को कुछ कम करने के लिए अपने सर्वोत्तम हित में संभव है, जैसे p। दूसरे नोट पर, आप दो रिक्तियाँ निकाल सकते हैं - एक बीच में printऔर '\n'दूसरी बीच )))और for।

— Sp3000

@ Sp3000 ठीक है, ध्यान देने के लिए धन्यवाद! निश्चित! ()

— कास्रामव्ड

२:def p(N):print'\n'.join(' '.join(map(str,range(1,i+2)))for i in range(N))

— १५'१५

2

पर्ल, २,

स्टड से पैरामीटर पढ़ता है।

@x=1..$_,print"@x
"for 1..<>

कमांड लाइन से:

perl -E'$,=$";say 1..$_ for 1..<>'

लेकिन मैं अब कैसे (शायद 25 और 29 के बीच) गिनती करने के लिए नहीं है।

— nutki
स्रोत

1

अजगर

import string
N,s=int(input()),list(string.digits)
for i in range(1,N+1):
    print(' '.join(s[1:i+1]))

— bacchusbeale
स्रोत

1

क्या यह विफल नहीं होता है यदि N> = 10?

— १३

@Sieg हाँ तुम सही हो। मैं सिर्फ पायथन सीख रहा हूं, स्ट्रिंग्स की सूची में इंट की सूची में परिवर्तित करने के तरीके की तलाश कर रहा था।

— bacchusbeale

63 बाइट्स: for i in range(int(input())):print(' '.join("123456789"[:i+1]))- ध्यान दें कि स्ट्रिंग्स को सूचियों के रूप में माना जाता है।

— देखिए

1

गोल्फस्क्रिप्ट 14

,{2+,1>' '*n}/

स्टैक पर मौजूद इनपुट संख्या की अपेक्षा करता है।

ऑनलाइन उदाहरण: लिंक

— क्रिस्टियन लुपस्कू
स्रोत

1

क्लिप , १६

Jm[ijkw,1iwS},1n

व्याख्या

J                   .- join with newlines                           -.
 m[i        },1n    .- map numbers from 1 to numeric value of input -.
    jkw   wS        .- join with spaces                             -.
       ,1i          .- numbers from 1 to index                      -.

— Ypnypn
स्रोत

1

चले जाओ, 93 81 78 93 90 बाइट्स

func r(n int)(s string){s=string(n+48);if n!=1{s=r(n-1)+" "+s};println(s);return}

वर्तमान असंगठित

func r(n int) (s string) {
    // Convert n to a string, we do not have to initialize s since
    // we hijacked the return value.
    // Numbers in the ascii table starts at 48
    s = string(n | 48)
    // Unless we are on our last iteration, we need previous iterations,
    // a space and our current iteration
    if n != 1 {
        // Collect the result of previous iteration for output
        s = r(n-1) + " " + s
    }
    println(s)
    // We can use a naked return since we specified the
    // name of our return value in the function signature
    return
}

यदि हमें N> 9 को संभालने की आवश्यकता है, तो हम 78 बाइट्स पर निम्नलिखित का उपयोग कर सकते हैं, हालांकि इसके लिए fmtपैकेज को आयात करना आवश्यक है ।

func r(n int)(s string){s=Sprint(n);if n!=1{s=r(n-1)+" "+s};Println(s);return}

यदि हम आयात स्टेटमेंट को शामिल करते हैं तो अब मैं अपने शुरुआती समय में वापस आ गया हूं 93 92 90 बाइट्स

import."fmt";func r(n int)(s string){s=Sprint(n);if n>1{s=r(n-1)+" "+s};Println(s);return}

इसे यहाँ ऑनलाइन टेस्ट करें: http://play.golang.org/p/BWLQ9R6ilw

इसके साथ संस्करण fmtयहां है: http://play.golang.org/p/hQEkLvpiqt

— क्रिस्टोफ़र साल्-स्टोर्गार्ड
स्रोत

मुझे यकीन नहीं है कि मैं स्ट्रिंग कास्ट के बारे में कैसा महसूस करता हूं, लेकिन इसे बाइट सरणी में बदलने का कोई भी प्रयास सिर्फ इसे लंबा बनाता है

— क्रिस्टोफ़र साल्-स्टॉरगार्ड

मुख्य समस्या यह है कि मैं n> 9 के लिए काम नहीं करता है। आप को बदलने के द्वारा एक बाइट बचा सकते हैं !=करने के लिए >है, हालांकि।

— जियोबिट्स

@Bigtoes, अब तय है, मैं नहीं जानता कि अगर मैं importबयान को गिनने वाला हूं, लेकिन

— क्रिस्टोफ़र सॉल-स्टॉरगार्ड

मुझे पता है कि वे उन भाषाओं के लिए गिने जाते हैं जिनसे मैं अधिक परिचित हूं, इसलिए सबसे अधिक हाँ। बेकार है, मुझे पता है :)

— Geobits

1

जेडएक्स / सिनक्लेयर बेसिक - 39 बाइट्स

ZX बेसिक प्रति कीवर्ड 1 बाइट (सभी अपरकेस शब्द) का उपयोग करता है, इसलिए बाइट का आकार थोड़ा नीचे रखने में मदद करता है ...

1 INPUT n:FOR i=1 TO n:FOR j=1 TO i:PRINT j;" ";:NEXT j:PRINT:NEXT i

N = 8 का उपयोग करना

यहाँ छवि विवरण दर्ज करें

— ब्रायन
स्रोत

1

अच्छा लगा। लेकिन ZX बुनियादी प्रत्येक संख्यात्मक शाब्दिक के लिए 6 अधिक छिपे हुए बाइट्स का उपयोग करता है (एक सामान्य चाल थी VAL("1")(6 बाइट्स वैल 1 है) 1(7 बाइट्स) के लिए

— edc65

1

आर, २ 28

for(i in 1:scan())print(1:i)

— freekvd
स्रोत

आउटपुट 0. के इनपुट मान के लिए गलत है। इसके अलावा, यह स्पष्ट नहीं है कि [1]प्रत्येक पंक्ति में अग्रणी कल्पना के उल्लंघन में है या नहीं।

— एलेक्स ए।

@AlexA। यदि आप इस प्रश्न को करीब से देखते हैं, तो आप मेरी टिप्पणी को देखेंगे कि n = 0 के लिए क्या व्यवहार होना चाहिए। लेकिन मुझे सही दिशा में इशारा करने के लिए धन्यवाद!

— freekvd

मैंने टिप्पणी देखी। बात यह है कि यह 0 के लिए कुछ भी नहीं प्रिंट करता है, यह प्रिंट करता है 1; 1 0। (प्रेटेंड ;एक लाइन ब्रेक है।)

— एलेक्स ए।

आप का उपयोग करने पर भी विचार कर सकते हैं cat(1:i,"\n")। भले ही यह थोड़ा लंबा है print(1:i), लेकिन इसमें [1]प्रत्येक पंक्ति में अग्रणी शामिल नहीं है ।

— एलेक्स ए।

1

टीआई-बेसिक, 28 बाइट्स

Input N
For(I,1,N
randIntNoRep(1,N->L1
SortA(L1
Disp L1
End

— Timtech
स्रोत

1

यह आउटपुट के रूप में इंगित नहीं करता है; बल्कि, सरणी को प्रदर्शित किया जाता है, कोष्ठक और सभी, होमस्क्रीन पर।

— दोपहर

1

सी, 89 वर्ण

// 90 characters
f(int n){int a=1,b;for(;n--;++a){for(b=0;b<a;++b)printf("%c%d",(!!b)*' ',b+1);puts("");}}

के बारे में भ्रम को खत्म करना puts("");। यह बस एक नई रेखा को प्रिंट करता है (जैसा कि यहाँ देखा गया है ):

ध्यान दें कि यह न केवल विवादों से अलग है, बल्कि यह गंतव्य के रूप में स्टडआउट का उपयोग करता है, लेकिन यह स्वचालित रूप से अंत में एक नया चरित्र भी जोड़ता है (जो कि विवाद नहीं करता है)।

मुझे यह @BestOne के जावा एल्गोरिथ्म से थोड़ा छोटा लगा:

// 89 characters
f(int a){char b[999]="",*p=b+1;int c=0;for(;a--&&(sprintf(b,"%s %d",b,++c)&&puts(p)););}

— फेलिक्स बायटॉ
स्रोत

puts("");कुछ नहीं करता। आप 1 वर्ण को बचाने के char b[999]=""बजाय उपयोग कर सकते हैं char b[999]={0}।

— मातृ एवं शिशु स्वास्थ्य

2

puts("");एक नए चरित्र को प्रिंट करता है।

— फेलिक्स बायटॉ

1

पर्ल: 34 अक्षर

print"@$_\n"for map[1..$_],1..$_;

इस कोड को विशेष चर के माध्यम से आपूर्ति की गई इनपुट संख्या मिलती है $_।

— फेलिक्स बायटॉ
स्रोत

1

अधिकांश कोष्ठक यहां बेमानी हैं: print"@$_\n"for map[1..$_],1..$_यह भी काम करता है।

— नटकी

मैंने कोड समायोजित किया।

— फेलिक्स बायटॉ

1

सी # - 94 बाइट्स

एक अनाम फ़ंक्शन के रूप में लिखा गया है जो एक स्ट्रिंग लौटाता है, जो कल्पना द्वारा अस्वीकृत नहीं लगता है।

n=>String.Join("\n\n",Enumerable.Range(1,n).Select(l=>String.Join(" ",Enumerable.Range(1,l))))

यहाँ एक अनगुल्ड संस्करण है (टिप्पणियाँ BDCA आदेश में पढ़ी गई हैं):

n =>
    String.Join("\n\n",                    //...then join it together with newlines.
        Enumerable.Range(1, n).Select(l => //For each l from 1 to n, ...
                String.Join(" ",              //...and join it with spaces, ...
                    Enumerable.Range(1, l)    //...get the range from 1 to l, ...

— LegionMammal978
स्रोत

1

बैश + कोरुटिल्स, 26 बाइट्स

seq $1|sed "x;G;s/\n/ /;h"

seq बस संख्या 1 से n उत्पन्न करता है
sed होल्ड स्पेस में दिए गए लाइन के लिए पूरे आउटपुट को सेव करता है, और फिर अगली लाइन को इसमें जोड़ देता है।

— डिजिटल आघात
स्रोत

1

हास्केल, 62 57 बाइट्स

e=enumFromTo 1
f=putStr.unlines.map(unwords.map show.e).e

बिंदु मुक्त शैली। उपयोग उदाहरण:

Prelude> f 5
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

— nimi
स्रोत

डूइंग e=enumFromTo 17 बाइट्स बचाता है।

— जर्बर्ग

@Zgarb: धन्यवाद, लेकिन अगर मैं बाहर स्वैप करता हूं, तो मुझे enumFromTo 1मुख्य फ़ंक्शन को एक नाम देना होगा, इसलिए, यह 5 बाइट्स है। नाम के बिना यह एक letनिर्माण होगा:let e=enumFromTo 1 in (putStr.unlines.map(unwords.map show.e).e) 5

— नीमी

1

गणितज्ञ, ३२

Print@Row[Range@i," "]~Do~{i,#}&

— alephalpha
स्रोत

1

कैसे के बारे में TableForm[Range/@Range@#]&?

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

1

कम:Grid[Range/@Range@#]&

— alephalpha

और यह बेहतर भी दिखता है। :) (मैं इसके बारे में भूल जाता हूं Grid।)

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

लेकिन मुझे यकीन नहीं है कि अगर प्रत्येक पंक्ति के अंत में कोई अनुगामी स्थान नहीं है।

— ऐलफाल्फा

ओह अच्छा बात है। :(

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

1

स्काला, 73 65 62 बाइट्स

(n:Int)=>print(1 to n map(1 to _ mkString " ") mkString "\n")

Ungolfed

def printNumberTriangle(n: Int): Unit = {
  def rowString(m: Int): String = 1.to(m).mkString(" ")
  print(1.to(n).map(rowString).mkString("\n"))
}

— डेव स्वार्ट्ज
स्रोत

प्रिंट संख्या त्रिकोण

जो , 5 3 बाइट्स ( -tझंडे के लिए +2 या +3 )

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

एपीएल, ५

जे, 27 बाइट्स

PHP, 53 बाइट्स

CJam, 13 12 बाइट्स

अजगर, 9 बाइट्स

जावास्क्रिप्ट (ईएस 6) 49 52

जावा, 85 84 बाइट्स

प्रस्तावना - ११ ९

जे, 9 वर्ण

> <> (मछली) , 40 37 + 3 = 40 बाइट्स

व्याख्या

सी (कोई छोरों के साथ, हाँ!) - 72 बाइट्स

अजगर 2 - 72

पर्ल, २,

अजगर

गोल्फस्क्रिप्ट 14

क्लिप , १६

व्याख्या

चले जाओ, 93 81 78 93 90 बाइट्स

वर्तमान असंगठित

जेडएक्स / सिनक्लेयर बेसिक - 39 बाइट्स

आर, २ 28

टीआई-बेसिक, 28 बाइट्स

सी, 89 वर्ण

पर्ल: 34 अक्षर

सी # - 94 बाइट्स

बैश + कोरुटिल्स, 26 बाइट्स

हास्केल, 62 57 बाइट्स

गणितज्ञ, ३२

स्काला, 73 65 62 बाइट्स

जो , 5 3 बाइट्स ( `-t`झंडे के लिए +2 या +3 )