मुख्य कार्य

आपका कार्य पूर्णांक को अवरोही क्रम में प्रिंट करना है, 1 से शुरू हो रहा है, और जब आप दिए गए इनपुट तक नहीं पहुंचते हैं, तब तक बढ़ते रहें, तब तक, बाकी को तब तक प्रिंट करें जब तक कि आप फिर से 1 हिट न कर दें। इनपुट के साथ उदाहरण 6:

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321

साइड नोट: यह OEIS में A004736 है। इसके अलावा, पहला उदाहरण (newlines के साथ) एक अमान्य आउटपुट है, जैसा कि नियमों में निर्दिष्ट है।

इनपुट

आपका कोड किसी भी प्रकार के इनपुट (चित्रमय, एसटीडीआईएन) को पूर्णांक या संख्या के रूप में ले सकता है।

उत्पादन

आपके कोड को ऊपर वर्णित अनुक्रम को आउटपुट करना चाहिए, जब तक कि इनपुट नंबर तक नहीं पहुंच जाता है, तब तक आउटपुट पर समाप्त हो जाता है जब तक कि यह फिर से 1 तक नहीं पहुंच जाता। आउटपुट कुछ भी हो सकता है, इसलिए नंबर, स्ट्रिंग्स, पूर्णांक या ग्राफ़िकल आउटपुट। यह एक एकल संख्या (यदि यह एक तार है तो कोई नया अंक नहीं है) का प्रिंट आउट लेना आवश्यक है। आपका आउटपुट अंदर हो सकता है और आपको जरूरत के अनुसार अधिक वर्णों के साथ प्रस्तुत किया जा सकता है (जैसे [])।

चूंकि कुछ गलतफहमी थी, यहाँ एक रेगेक्स पैटर्न है जिस पर आप अपने आउटपुट की कोशिश कर सकते हैं।

^(\D*(\d)+\D*)$

नियम

आउटपुट एक पूर्ण संख्या होनी चाहिए, कुछ भी विभाजित नहीं होना चाहिए, यहां तक कि न्यूलाइंस भी नहीं।
एल्गोरिथ्म किसी भी तरह से (जैसे ) 21में दिखाई देने वाले एन के पहले उदाहरण के लिए जांच नहीं करना चाहिए 121321, बल्कि वास्तविक संख्या के रूप में एन के पहले उदाहरण के लिए।
एक एकल अनुगामी न्यूलाइन की अनुमति है।
नकारात्मक इनपुट के लिए हैंडलिंग पूरी तरह से आपकी पसंद है, नकारात्मक संख्याएं आपके द्वारा परीक्षण किए जाने वाले मामले नहीं हैं।

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

Input: 6
Output: 121321432154321654321

Input: 1
Output: 1

Input: 26
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0
Output: 0, Empty, or Error

Input: 21
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

धन्यवाद @Emigna, मैंने इन परीक्षण मामलों की गणना करने के लिए उनके एल्गोरिथ्म का उपयोग किया।

विजेता

विजेता को चुना गया है! यह एक प्रभावशाली 5 बाइट्स के साथ एरिकगॉल्फ का जवाब था ! बधाई हो!

code-golf sequence integer

— devRicher
स्रोत

The output must be a full number ...क्या आप पूरे अनुक्रम का मतलब है, या केवल अलग substrings (1, 2-1, 3-1 ...)? आपका पहला उदाहरण इस कथन से मेल नहीं खाता है।

— steenbergh

1

यदि आउटपुट में एक ही नंबर होना है, तो यह "एरेज़" कैसे हो सकता है?

— SMLS

क्या यह सरणी आउटपुट के रूप में स्वीकार्य होगी? [1, 21, 321, 4321, 54321, 654321] इसके बारे में क्या खयाल है? [1,2,1,3,2,1,4,3,2,1,5,4,3,2,1,6,5,4,3,2,1] या आप सिर्फ एक ही तत्व के साथ सरणियों के बारे में बात कर रहे हैं, जैसे [121321432154321654321]?

— SMLS

1

मैं आउटपुट प्रारूप के बारे में उलझन में हूँ। क्या आप इस बात का उदाहरण दे सकते हैं कि क्या स्वीकार्य है? नंबरों की एरियर? रिक्त स्थान से अलग संख्याओं के साथ स्ट्रिंग?

— लुइस मेन्डो

1

आपका रेगेक्स आउटपुट देता है mickey321211mouse। वास्तव में \Dभागों के होने का कोई कारण नहीं है

— edc65

13

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

RRUVV

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

फॉर्मूला मेरा नहीं है।

मुझे शक है कि यहाँ बहुत कुछ हो रहा है ...

[जवाब दिया] मैंने डेनिस को कुछ 5 प्रतिनिधि दिए हैं, लेकिन यह प्रतिष्ठा विनिमय नहीं है। डेनिस ने मुझे VVव्यवहार दिखाया । मेरे आश्चर्य के लिए, यह 05AB1E से कम है।

— आउटग्रॉफर को एरिक करें
स्रोत

बधाई हो, इस कोड में सबसे कम कोड है!

— devRicher

19

05AB1E , 6 बाइट्स

L€LíJJ

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

व्याख्या

उदाहरण इनपुट 4

L       # range [1 ... input]
        # STACK: [1,2,3,4]
 €L     # map: range
        # STACK: [[1],[1,2],[1,2,3],[1,2,3,4]]
   í    # reverse each
        # STACK: [[1],[2,1],[3,2,1],[4,3,2,1]]
    J   # join inner lists
        # STACK: ['1','21','321','4321']
     J  # join list
        # OUTPUT: 1213214321

— Emigna
स्रोत

13

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

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

डेमो

कोड स्निपेट दिखाएं

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

console.log(f(6))

स्निपेट का विस्तार करें

N <10, 34 बाइट्स (गैर-प्रतिस्पर्धात्मक) के लिए वैकल्पिक विधि

f=(n,s='1')=>--n?s+f(n,++s[0]+s):s

जावास्क्रिप्ट में, तार अपरिवर्तनीय हैं। इसलिए, sएक नया मान निर्दिष्ट करके स्ट्रिंग के Nth वर्ण की सामग्री को बदलना असंभव है s[N]।

हालांकि, अभिव्यक्ति ++s[N]वैध है और मूल्यांकन करता है क्योंकि एक स्ट्रिंग अपरिवर्तित रहता है, भले ही वह अपेक्षा करता है। उदाहरण के लिए:

++"1"[0] // equals 2

और विस्तार से:

s = "21"
++s[0] + s // equals "321"

— Arnauld
स्रोत

N> 9

— edc65

@ edc65 आप बिल्कुल सही कह रहे हैं। मैं नहीं जानता कि क्यों मैंने सोचा 9. पर इसे रोकने के लिए ठीक था

— Arnauld

12

V, 29 28 27 23 19 19 17 बाइट्स

8 बाइट्स ने @DJMcMayhem को धन्यवाद दिया

3 बाइट्स ने @ nmjcman101 को धन्यवाद दिया

"apÀñÄòy$jpkgJ

छिपे हुए पात्र:

"apÀ<C-x>ñÄ<C-x>òy$jpkgJ

C-x Ctrl + x है।

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

Hexdump:

0000000: 2261 70c0 adf1 c418 f279 246a 706b 674a  "ap......y$jpkgJ

व्याख्या

"ap            Paste the argument
À<C-x>         Argument minus 1 times (so that we exclude the 0)
ñ ... ò        Loop (for some weird reason the ò closes the ñ)
Ä<C-x>         paste current line above and decrement it

अब यह दिखता है:

1
2
...
n

जारी रखा ...

ò             recursively do (until a breaking error)
y$             yank this line
  jp           paste it down
    kgJ        go up and join
              implicit ò end

GIF (पुराना)

(arg के लिए 6)

— क्रिकटी लिथोस
स्रोत

मैं अपने पाश को बदलकर कुछ प्राप्त कर रहा हूं) अंत में स्पष्ट रूप से और बी) लाइनों में शामिल हो जाएं क्योंकि यह जाता है (बजाय अंत में)òy$jpkgJ

— nmjcman101

@ nmjcman101 मुझे 2 बाइट बचाने में मदद करने के लिए धन्यवाद!

— क्रिक्टी लिथोस

यह बहुत अच्छी तरह से गोल्फ है। मैं एक अच्छे 20 मिनट के लिए अपने दिमाग की रैकिंग कर रहा हूं, और मैं कुछ भी छोटा नहीं सोच सकता। :)

— डीजेएमसीएम

@DJMcMayhem ऐसा इसलिए है क्योंकि मुझे कुछ बड़ी मदद मिली है :)

— Kritii Lithos

मैंने यह किया! आप नीचे 16 बाइट्स प्राप्त कर सकते हैं। यदि आप arg को पेस्ट करते हैं, और फिर डुप्लिकेट / डीक्रीमेंट ऊपर की तरफ करते हैं, तो आप H को हटाते हैं। फिर यदि आप अपने पर decrement ऑपरेटर का उपयोग करते हैं À, तो आपके पास शीर्ष पर 0 नहीं होगा जिससे आप x निकाल सकते हैं। तब APPARENTLY एक òबंद कर देगा ñताकि आप दूसरे को हटा सकें ñ(जो आपके द्वारा सेव की गई बाइट है)। लिंक क्योंकि कोई मतलब नहीं था

— nmjcman101

11

सी #, 72 69 65 बाइट्स

n=>{for(int i=0,j;i<n;)for(j=++i;j>0;)System.Console.Write(j--);}

अगर आउटपुट को कंसोल में लिखे जाने के विपरीत ही लौटाया जा सकता है

सी #, 71 68 64 बाइट्स

n=>{var s="";for(int i=0,j;i<n;)for(j=++i;j>0;)s+=j--;return s;}

बहुत सारे बाइट्स बचाने के लिए @VisualMelon का धन्यवाद

इसे यहाँ टेस्ट करें (420 के ऊपर किसी भी नंबर पर विनम्रतापूर्वक ऑनलाइन कंपाइलर टूट जाता है)

— अल्फी गुडाकरे
स्रोत

यह वास्तव में तेज था।

— devRicher

@devRicher मैं क्या कह सकता हूं, मैं कुछ पोस्ट होने का इंतजार कर रहा था: पी

— अल्फी गुडाक्रे

2

सी # कोड गोल्फ में थोड़ी देर के लूप का उपयोग करने का कोई कारण नहीं है, एक लूप हमेशा बेहतर नहीं होने पर भी प्रदर्शन करेगा। इस मामले में, आप j=1फॉर-लूप के असाइनमेंट को शामिल कर सकते हैं , और सेमी-कोलोन को बचा सकते हैं। आप को बचाने के लिए, jके साथ भी घोषित कर सकते हैं । भी ले जाया जा सकता एक बाइट बचत, असाइनमेंट। यदि आप इसके बजाय इसे बनाते हैं और शुरू करते हैं , तो आपको इसके साथ बदलने में भी सक्षम होना चाहिए । iinti++j=ii<=ni<nj=++ii0

— विजुअलमेल डे

@VisualMelon ने इसे संपादित किया, 3 बाइट्स बचाए! साथ में चींटियों की घोषणा वास्तव में बाइट की गिनती में कोई फर्क नहीं पड़ता है, लेकिन यह छोरों को थोड़ा अच्छा दिखता है

— अल्फी गुडाक्रे

@AlfieGoodacre यदि आप उन्हें लूप के लिए एक साथ घोषित करते हैं, तो आप 2 और बाइट्स बचाएंगे for(int i=0,j;i<n;);) {}लूप के लिए भीतर के आसपास की भी कोई जरूरत नहीं है ।

— विजुअलमेल डे

8

शुद्ध बैश, ३४

eval eval printf %s \\{{1..$1}..1}

ब्रेस विस्तार के दो स्तर। इनपुट के साथ 6, पहले स्तर का विस्तार होता है {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}। इसके बाद इसका विस्तार होता है 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, जिसे एक स्ट्रिंग के साथ एक साथ तोड़ दिया जाता है printf %s। evalविस्तार के दोनों स्तरों पर आवश्यक हैं - पहले स्तर के लिए ताकि $1पैरामीटर पहले विस्तारित हो, और दूसरे स्तर के लिए ताकि यह पहले स्तर के बाद फैल जाए।

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

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

8

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

-Eबिना किसी अतिरिक्त लागत के उपयोग ।

say map$}=$_.$},1..<>

प्रयोग

perl -E 'say map$}=$_.$},1..<>' <<< 6
121321432154321654321

— डोम हेस्टिंग्स
स्रोत

7

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

jks}R1S

एक प्रोग्राम जो एक पूर्णांक का इनपुट लेता है और परिणाम को प्रिंट करता है।

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

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

jks}R1S   Program. Input: Q
jks}R1SQ  Implicit input fill
    R     Map
      SQ  over [1, 2, 3, 4, ..., Q] with i:
   } 1     Yield [i, i-1, i-2, i-3, ..., 1]
  s       Merge
jk        Join
          Implicitly print

— TheBikingViking
स्रोत

व्यक्तिगत रूप से मैं बहुत निराश हूं जो jk_hC.:Sलंबा है, लेकिन अच्छा काम है!

— FryAmTheEggman

7

जप , 67 बाइट्स

1
InputBox[a]
Sum[Join[Sequence[Sequence[Text[j],j,i,1,-1],i,1,a]]]

प्रत्येक पंक्ति को इनपुट बार में अलग से दर्ज किया जाता है। इनपुट बॉक्स से इनपुट लिया जाता है।

यहाँ निष्पादन की एक झलक है:

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

में प्रवेश कर 1परोक्ष प्रदान करती है aकरने के लिए 1, और InputBoxआदेश के साथ एक इनपुट बॉक्स एकत्रित करती है a। फिर, प्रत्येक iके लिए {1, 2, 3, ..., a}, कमांड {i, i-1, i-2, ..., 1}का उपयोग करके सूची बनाई जाती है Sequence, और jउस सूची में प्रत्येक का उपयोग करके स्ट्रिंग में परिवर्तित किया जाता है Text। अंत में, Joinसभी सूचियों को मर्ज कर देता है, औरSum सभी तत्वों को एक पाठ ऑब्जेक्ट में जोड़ता है, जो प्रदर्शित होता है।

— TheBikingViking
स्रोत

@devRicher उचित लगता है। धन्यवाद!

— बाइकिंग लंबी पैदल यात्रा

7

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

r=s=''
n=0
exec'n+=1;s=`n`+s;r+=s;'*input()
print r

— मिच श्वार्ट्ज
स्रोत

7

रेटिना , 26 22 बाइट्स

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

.+
$*

$`¶
1
$.%'
0?¶

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

व्याख्या

.+
$*

इनपुट को यूनीरी में बदलें।


$`¶

प्रत्येक स्थिति में, उपसर्ग को उस बिंदु तक सम्मिलित करें, साथ ही साथ एक लाइनफीड भी। यह प्रति पंक्ति एक मान 2से n+1, एक मान सीमा बनाता है ।

1
$.%'

प्रत्येक 1को उसी पंक्ति पर वर्णों की संख्या से बदलें । यह कुछ इस तरह 11111से बदल जाता है 43210।

0?¶

सभी लाइनफीड्स और उन्हें पूर्ववर्ती शून्य हटा दें।

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

5

गेममेकर भाषा, 65 बाइट्स

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(c--)}return b

— Timtech
स्रोत

5

एपीएल, 10 बाइट्स

∊⍕¨∘⌽∘⍳¨∘⍳

उदाहरण के लिए:

      (∊⍕¨∘⌽∘⍳¨∘⍳)6
121321432154321654321

स्पष्टीकरण:

⍳: 1 से एन तक संख्या प्राप्त करें।
⍳¨∘: उनमें से प्रत्येक के लिए, 1 से एन तक संख्याएं प्राप्त करें।
⌽∘: उस सूची को उल्टा करें
⍕¨∘: प्रत्येक आइटम का चरित्र प्रतिनिधित्व प्राप्त करें (इसलिए यह बीच में रिक्त स्थान के साथ संख्याओं का उत्पादन नहीं करता है)
∊: परिणामी सरणी को समतल करें

— मारीनस
स्रोत

तो यह कोड को पीछे की तरफ पार्स कर रहा है?

— devRicher

∘फ़ंक्शन रचना है, मैंने इस क्रम में स्पष्टीकरण दिया कि कार्यों का वास्तव में मूल्यांकन किया गया है

— Marinus

1

यहाँ उत्सुकता के लिए, पार्स ट्री है: tryapl.org/…

— marinus

5

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

मैं शर्त लगाता हूं कि एक पुनरावर्ती समाधान कम हो सकता है, लेकिन मुझे इसमें एक कठिन समय तैयार हो रहा है।

n=input()
i=0
o=""
while i<n:
    i+=1;j=i
    while j:o+=`j`;j-=1
print o

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

— mbomb007
स्रोत

5

दरअसल 8 बाइट्स

RR♂RΣRεj

पहली बार वास्तव में एक उत्तर पोस्ट करना ताकि यह संभवतः गोल्फ हो सके।

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

Program takes implicit input, implicit print at EOF
R           Takes the input and creates a range (1, input)   
                STACK = [1,2,..,n]
 R          Reverse the top stack item (our range)
                STACK = [n,..,2,1]
  ♂R        For each item in our range, create a range (1, rangeitem)
                STACK = [[1,2,..,n], .., [1,2], [1]]
    Σ       Stitch the items of the list together
                STACK = [n,..,1,2,3,1,2,1]
     R      Reverse the top stack item again (our answer)
                STACK = [1,2,1,3,2,1,..n]
      εj    Create an empty string and append each item from the list to it.
            (turns non string items into strings)

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

— पेल पेलिकन
स्रोत

1

मुझे यकीन है कि वहाँ नहीं कर रहा हूँ है एक छोटी समाधान है, लेकिन मैं अपने आप को पहले गलत साबित कर दिया है। किसी भी मामले में, यहां आपके उत्तर के लिए एक कोशिश ऑनलाइन लिंक है ।

— शर्लक

1

कोड R♂R♂RΣεjबाइट्स की समान संख्या है, लेकिन इसके लिए स्पष्टीकरण लिखना आसान हो सकता है।

— शर्लक

@ शर्लक 9 आपका रास्ता थोड़ा और सुरुचिपूर्ण है, मैंने लिंक और एक स्पष्टीकरण जोड़ा है जिसे मैं कल पर जोड़ना भूल गया, इसे थोड़ा और समझाने की कोशिश करता हूं।

— चैले पेलिकन

4

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

yb@[rcw\

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

व्याख्या

yb         The list [1, ..., Input]
  @[       Take a prefix of that list
    rc     Reverse it and concatenate into an integer
      w    Write to STDOUT
       \   Backtrack: try another prefix

— Fatalize
स्रोत

4

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

{[~] flat [\R,] 1..$_}

एक लंबोदर जो एक स्ट्रिंग लौटाता है।

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

स्पष्टीकरण:

1..$_: पूर्णांक की सीमा ... (1 2 3 4)
[,] 1..$_: अल्पविराम ऑपरेटर पर कम ("गुना") ... (1 2 3 4)
[\,] 1..$_: मध्यवर्ती परिणामों के साथ ( त्रिकोणीय कम) ) के साथ ...((1) (1 2) (1 2 3) (1 2 3 4))
[\R,] 1..$_: उलटा मेटा-ऑपरेटर को अल्पविराम पर लागू करें ...((1) (2 1) (3 2 1) (4 3 2 1))
[~] flat ...: सूची घोंसले के शिकार को निकालें, और स्ट्रिंग कॉनैट ऑपरेटर पर गुना ... 1213214321

— SMLS
स्रोत

4

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

f x=[1..x]>>= \y->[y,y-1..1]>>=show

उपयोग उदाहरण: f 6->"121321432154321654321"।

सभी नंबरों के लिए xमें 1 ... xमेकअप एक सूची x,x-1, ... ,1, एक स्ट्रिंग में संख्या कर देते हैं और उन्हें एक ही स्ट्रिंग में श्रेणीबद्ध। फिर से, एक तार में उन तारों को समतल करें।

— nimi
स्रोत

4

C89, 54 बाइट्स

i,j;f(n){for(i=1;j<=n;j=i++)while(j)printf("%d",j--);}

५६ -2 = ५४ एरिकगॉल्फ के लिए धन्यवाद!

— बिल्ली
स्रोत

मुझे लगता है कि आप (j=i++)इसके बजाय (j=i)अंतिम i++(निष्कलंक) को हटा सकते हैं ।

— 15

यहाँ एक छोटा पुनरावर्ती संस्करण है: i,j;f(n){j=++i;while(j)printf("%d",j--);i-n?f(n):0;}(52 बाइट्स)

— स्टैडिओक्स

@Steadybox आप अपने खुद के जवाब के रूप में जोड़ सकते हैं यदि आप चाहें, लेकिन धन्यवाद!

— बिल्ली

@cat ठीक है, धन्यवाद, बस किया। अगर मुझे केवल आपके समाधान का संपादन करना चाहिए तो मुझे यकीन नहीं था।

— स्टेच्यूबॉक्स

4

पायथन 3, 87 92 83 74 बाइट्स

lambda n:"".join(["".join([str(i)for i in range(1,k)][::-1])for k in range(1,n+2)])

पुनरावृत्ति का उपयोग करते हुए छोटा उत्तर:

f=lambda n:f(n-1)+"".join([str(i)for i in range(1,n+1)][::-1])if n>0else""

शायद सबसे छोटा नहीं है, लेकिन यह केवल पायथन की सूची की समझ के साथ बनाया गया है!

(प्रिंट फ़ंक्शन को जोड़ने और \ n को निकालने के लिए संपादित)

(प्रिंट फ़ंक्शन को हटाने, और n + 1, k + 1 से n, k + 2 को बदलने के लिए संपादित)

— Sygmei
स्रोत

K, n + 2 के साथ काम करता है, लेकिन k + 2, n के साथ नहीं, हालांकि विचार के लिए धन्यवाद :)

— Sygmei

कोड जो आप स्कोर कर रहे हैं वह पहले होना चाहिए। इसके अलावा, आपको पायथन 2 का उपयोग करना चाहिए और फिर `i`इसके बजाय का उपयोग करना चाहिए str(i)। और आप के "".join(...)बजाय का उपयोग कर सकते हैं "".join([...]), और range(1,k,-1)हटाने के लिए [...][::-1]।

— mbomb007

भी, n>0हो सकता है n। और मेरा मतलब था range(n,0,-1)। और उपयोग करें n and f(n-1)+...)or""।

— mbomb007

1

62 बाइट्स । दरअसल, यह इस जवाब के बहुत करीब हो सकता है ।

— mbomb007

हाँ यह बहुत करीब हो रहा है, मैंने देखा कि अपना दूसरा संस्करण करने के बाद :(

— Sygmei

3

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

jks_M._S

व्याख्या

jks_M._SQ   Implicit input
       SQ   Get the range [1, 2, ..., N]
     ._     Get each prefix
   _M       Reverse each prefix
jks         Join everything as a string

— स्मृति सहायक
स्रोत

3

05AB1E , 6 बाइट्स

LR.sJJ

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

— अदनान
स्रोत

3

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

ToString/@(""<>Range[Range@#,1,-1])&

चेतावनी का एक गुच्छा फेंकता है जिसे सुरक्षित रूप से अनदेखा किया जा सकता है।

व्याख्या

5उदाहरण के रूप में इनपुट का उपयोग करना :

Range@#

एक सीमा बनाता है {1, 2, 3, 4, 5}।

Range[...,1,-1]

Rangeसूचीबद्ध है, इसलिए हम इसे इसके किसी भी तर्क के लिए एक सूची दे सकते हैं और यह स्वचालित रूप से उस तर्क पर थ्रेड करेगा। तो यह हमें उलटी सूचियों का एक गुच्छा देता है:

{{1}, {2, 1}, {3, 2, 1}, {4, 3, 2, 1}, {5, 4, 3, 2, 1}}

आगे:

(""<>...)

यह रिक्त स्ट्रिंग के साथ नेस्टेड सूची में शामिल होता है। चूंकि नेस्टेड सूची में वास्तव में कोई तार नहीं है, यह वास्तव में मूल्यों में शामिल नहीं हो सकता है (जो कि जहां चेतावनी उत्पन्न होती है), लेकिन ""<>सूची को समतल करने का दुष्प्रभाव है। तो यह हमें देता है

1 <> 2 <> 1 <> 3 <> 2 <> 1 <> 4 <> 3 <> 2 <> 1 <> 5 <> 4 <> 3 <> 2 <> 1

अब मैथेमेटिका की सुंदर विशेषता आती है जो Mapउस संरचना के बारे में परवाह नहीं करती है जो इसे मैप कर रही है। आप सामान्य रूप से इसे एक सूची में लागू करते हैं, लेकिन यह किसी भी सिर के साथ काम करता है। f /@ h[a, b, c]बस आपको देता है h[f[a], f[b], f[c]]। हमारे मामले में, सिर है StringJoinऔर मान पूर्णांक हैं।

ToString/@...

तो यह बस पूर्णांकों को तार में बदल देता है। उस बिंदु पर StringJoin[...]पता है कि उनके साथ क्या करना है और उन सभी को एक स्ट्रिंग में शामिल करना है:

"121321432154321"

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

1

यह सिर्फ सादा गंदा है। :)

— ग्रेग मार्टिन

3

GolfScript , 14 बाइट्स

~,{),{)}%-1%}%

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

बेशक विधि, लेकिन यह GolfScript है।

कोड के इस विशाल टुकड़े के लिए स्पष्टीकरण :

~,{),{)}%-1%}% # Code
               # Initial stack.      ["n"]
~              # Eval ToS.           [n]
 ,             # ToS' lowered range. [[0..n)]
  {),{)}%-1%}  # Block. 1 argument.  [a]
   )           # Increment.          [a+1]
    ,          # Range.              [[0..a)]
     {)}       # Block. 1 argument.  [b]
      )        # Increment.          [b+1]
        %      # Map.                [[1..a]]
         -1    # Integer. -1         [[1..a] -1]
           %   # Each nth element.   [[a..1]]
             % # Map.                [[[1],[2,1],...,[n..1]]]
               # Implicit output.    121...n..1

ध्यान दें कि आउटपुट एक एकल संख्या के रूप में है। अनुगामी \n।

— आउटग्रॉफर को एरिक करें
स्रोत

3

आर, 38 33 44 बाइट्स

if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")

एसटीडीआईएन पर इनपुट लेता है, और 1 से एन तक लूप करता है, प्रत्येक चरण के लिए अनुक्रम I से 1 बनाता है और इसे प्रिंट करता है।

संपादित करें: प्रतिस्थापित seq(i,1)द्वारा i:15 बाइट्स बचत और दिखा कारण है कि मैं बैठकों के दौरान गोल्फ नहीं करना चाहिए।

— JAD
स्रोत

यह तब उत्पन्न 101होता है जब इनपुट होता है 0। if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")उसने चाल चली।

— फ्रेडरिक

धिक्कार है, गैर-शून्य इनपुट ग्रहण किया :(

— JAD

if(n<-scan())पर्याप्त होना चाहिए।

— Giuseppe

3

MATL , 14 11 बाइट्स

:"@:P]v!VXz

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

व्याख्या

:      % Input N implicitly. Push range [1 2 ...N]
"      % For each k in [1 2 ...N]
  @:   %   Push range [1 2 ... k]
  P    %   Reverse
]      % End
v!     % Concatenate all arrays horizontally
V      % Convert to string
Xz     % Remove spaces. Display implicitly

— लुइस मेंडो
स्रोत

not split up by anythingलगता है कि दूसरे की अनुमति नहीं है।

— JAD

2

@JarkoDubbeldam मैं उस एक को हटा दूंगा जब तक कि ओपी स्पष्ट नहीं करता

— लुइस

1

@ जारको ओपी ने स्पष्ट किया। वर्तमान समाधान कल्पना के अनुरूप है

— लुइस मेन्डो

3

ब्रेनफक, 17 बाइट्स

>,[>[+.>]+.[<]>-]

व्याख्या

>           keep the first cell at 0
 ,          input of the decimal number into the cell
  [>        start a conditionnal loop and go to the next cell
   [+.>]    while it don't find 0, increment each cells and output the value
    +.      increment the new cell and output
     [<]    go to the first cell
      >-]   decrement the second cell and restart

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

— Milihhard
स्रोत

PPCG में आपका स्वागत है! क्या आपने अभी तक दौरा पृष्ठ और सबसे गर्म मेटा प्रश्नों को पढ़ा है? मैं आपको सलाह देता हूं, वे मददगार हैं! इसके अलावा, कोड स्वरूपण में अपना कोड लपेटें! क्या आपने प्रारूपण सहायता पढ़ी है? आपको यह भी बताना चाहिए कि आपका कोड कैसे काम करता है, यदि आप कर सकते हैं!

— देवचर

@ मड्डीफिश ने केवल स्पष्टीकरण में जोड़ा है

— मिलिहार्ड

मैंने एक मोबाइल ऐप का उपयोग किया है। आप परिणाम की स्क्रीन देख सकते हैं।

— मिलिहार्ड

नहीं यह ठीक है। लेकिन लिंक में, ouput ascii में है और दशमलव में नहीं है, इसलिए आपको वास्तव में आउटपुट नहीं दिखता है

— Milihhard

@muddyfish आपका पर्मलिंक एक टैड कन्फ्यूजिंग है। इनपुट में एक अदृश्य 0x06 है, उसके बाद दशमलव अंक 6 है ।

— डेनिस

3

पायथन , 63 57 59 बाइट्स

एक पुनरावर्ती समाधान जो पायथन 2 और 3 दोनों में काम करता है। यह संभवतः आगे गोल्फ हो सकता है। गोल्फ सुझाव आपका स्वागत है! इसे ऑनलाइन आज़माएं!

संपादित करें: -6 बाइट्स जोनाथन एलन के लिए धन्यवाद। मेरे जवाब के साथ एक समस्या को इंगित करने के लिए mbomb007 के लिए धन्यवाद के साथ +2 बाइट्स।

f=lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""

Ungolfing

def f(n):
    s = ""
    for i in range(n+1):
        m = map(str, range(n, 0, -1))
        s += "".join(m)
    return s

— Sherlock9
स्रोत

2

map6 बाइट्स बचाने के लिए एक का उपयोग करें :lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""

— योनातन एलन

2

PHP, 35 34 33 बाइट्स

एक बाइट को बचाया क्योंकि मैं दुखी हो गया, धन्यवाद टाइटस! और दुसरी!

while($i++<$argv[1])echo$s=$i.$s;

कमांड लाइन से चलाएं -r ।

सुंदर सरल उत्तर, हमारे इनपुट के माध्यम से 1 से लूप्स n, स्ट्रिंग की शुरुआत में संख्या से निपटना और इसे प्रिंट करना।

— Xanderhall
स्रोत

मेरी गिनती 34 है। पोस्ट-इंक्रीमेंट के साथ एक बाइट कम है।

— टाइटस

33 बाइट्स:while($i++<$argv[1])echo$s=$i.$s;

— aross

1

सीजेएम, 13 बाइट्स

ri,:){,:)W%}%

दुभाषिया

— आउटग्रॉफर को एरिक करें
स्रोत

आप 2 बाइट्स बचा सकते हैं:ri{),:)W%}%

— लुइस मेंडू

@LuisMendo नीट, इसके लिए धन्यवाद!

— 1921

नकारात्मक क्रम में आउटपुट पूर्णांक, अधिकतम पूर्णांक को हर बार बढ़ाते हैं

मुख्य कार्य

इनपुट

उत्पादन

नियम

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

विजेता

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

05AB1E , 6 बाइट्स

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

डेमो

N <10, 34 बाइट्स (गैर-प्रतिस्पर्धात्मक) के लिए वैकल्पिक विधि

V, 29 28 27 23 19 19 17 बाइट्स

व्याख्या

GIF (पुराना)

सी #, 72 69 65 बाइट्स

सी #, 71 68 64 बाइट्स

शुद्ध बैश, ३४

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

प्रयोग

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

जप , 67 बाइट्स

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

रेटिना , 26 22 बाइट्स

व्याख्या

गेममेकर भाषा, 65 बाइट्स

एपीएल, 10 बाइट्स

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

दरअसल 8 बाइट्स

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

व्याख्या

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

स्पष्टीकरण:

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

C89, 54 बाइट्स

पायथन 3, 87 92 83 74 बाइट्स

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

व्याख्या

05AB1E , 6 बाइट्स

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

व्याख्या

GolfScript , 14 बाइट्स

आर, 38 33 44 बाइट्स

MATL , 14 11 बाइट्स

व्याख्या

ब्रेनफक, 17 बाइट्स

व्याख्या

पायथन , 63 57 59 बाइट्स

PHP, 35 34 33 बाइट्स

सीजेएम, 13 बाइट्स