परिचय

एक उदाहरण के रूप में, चलो संख्या लेते हैं 7। हम फिर इसे डुप्लिकेट करते हैं और बीच में 7 स्थान रखते हैं। हमें यह मिलता है:

7_______7

उसके बाद, हम संख्या को कम करने जा रहे हैं, जब तक कि कोई रिक्त स्थान नहीं बचा है। हमें संख्या 7 के लिए निम्नलिखित मिलते हैं:

7_______7    
 6543210

फिर, हम उनमें से दो का विलय करते हैं, इसलिए:

7_______7    
 6543210  becomes

765432107

यह N = 7 के लिए आउटपुट होगा ।

आसान लगता है, है ना? अब N = 12 लेते हैं । हम फिर से दो नंबरों के बीच 12 स्थान डालते हैं, जो हमें देता है:

12____________12

फिर हम शुरू करते हैं:

12____________12
  111098765432

और यह अंत में हमें देता है:

1211109876543212

जैसा कि आप देख सकते हैं, अवरोही भाग 2 पर समाप्त होता है, 0 पर नहीं ।

कार्य

पूर्णांक को देखते हुए, 1 से अधिक , ऊपर दिखाए गए अनुसार अवरोही क्रम को आउटपुट करता है।

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

Input   Output

2       2102
3       32103
4       432104
5       5432105
6       65432106
7       765432107
8       8765432108
9       98765432109
10      10987654321010
11      111098765432111
12      1211109876543212
13      13121110987654313
14      141312111098765414
15      1514131211109876515
20      201918171615141312111020
99      9998979695949392919089888786858483828180797877767574737271706968676665646362616059585756555453525150499
100     1009998979695949392919089888786858483828180797877767574737271706968676665646362616059585756555453525150100

यह कोड-गोल्फ है , इसलिए सबसे कम संख्या में बाइट्स जीतता है!

code-golf number sequence

— अदनान
स्रोत

आंतरिक स्थान को पूरे नंबरों से भरा होना चाहिए या यदि आवश्यक हो तो हमें नंबरों को काटना चाहिए? उस बारे में कोई परीक्षण मामला नहीं है (उदाहरण के लिए 99)

— edc65

@ edc65 आपको जरूरत पड़ने पर नंबर काटना चाहिए। मैंने एक परीक्षण मामले के रूप में 99 को जोड़ा है।

— अदनान

8

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

q4*~,W%s<\

इसे ऑनलाइन आज़माएं। मानता है कि इनपुट में एक अनुगामी न्यूलाइन है। (बाइट बचाने के लिए @ jimmy23013 को धन्यवाद।)

व्याख्या

प्रत्येक पंक्ति के अंत में उस बिंदु पर स्टैक कैसा दिखता है ( 4उदाहरण के रूप में)।

q4*  e# Push input x 4 times, separated by newlines. ["4\n4\n4\n4\n"]
~    e# Evaluate, separating the 4's and converting them to numbers. [4 4 4 4]
,W%  e# Take the range of x and reverse it. [4 4 4 [3 2 1 0]]
s<   e# Cast to string and take the first x characters. [4 4 "3210"]
\    e# Swap the top two to get the final result. [4 "3210" 4]

— NinjaBearMonkey
स्रोत

9

जूलिया, 30 बाइट्स

n->"$n"join(n-1:-1:0)[1:n]"$n"

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

हम निर्माण करते हैं और एन -1 से 0 तक अवरोही अनुक्रम में शामिल होते हैं , और परिणामी स्ट्रिंग से पहले एन अक्षर लेते हैं। हम इसे एक स्ट्रिंग के रूप में इनपुट के साथ प्रस्तुत करते हैं और जोड़ते हैं।

सभी परीक्षण मामलों को ऑनलाइन सत्यापित करें

— एलेक्स ए।
स्रोत

5

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

s=show
f n=s n++take n(s=<<[n-1,n-2..])++s n

प्रयोग उदाहरण: f 14-> "141312111098765414"।

— nimi
स्रोत

5

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

n=>n+[...Array(m=n)].map(_=>--m).join``.slice(0,n)+n

संपादित करें: सहेजे गए 3 बाइट्स के लिए @WashingtonGuedes धन्यवाद।

— नील
स्रोत

@WashingtonGuedes बाह, मैं उपयोग करने के लिए कभी नहीं लगता .keys()।

— नील

.keys()की तरह है .reduce। नौकरी के लिए सही उपकरण, लेकिन आपको हमेशा कुछ ऐसा मिलता है जो उस विशेष मामले में बेहतर कर सकता है

— edc65

4

अजगर 2, 82 72 58 53 बाइट्स

lambda x:`x`+''.join(map(str,range(x)[::-1]))[:x]+`x`

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

मुझे सिखाने के लिए @ एलेक्स का शुक्रिया कि repr(x)= `x`मुझे बाइट्स का एक गुच्छा बचाकर!

— Denker
स्रोत

3

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

++Q<jk_UQQQ

दो वैकल्पिक संस्करण, जो सभी 11 बाइट्स ( आह ) भी हैं:

s[Q<jk_UQQQ
pQp<jk_UQQQ

  Q           the input
       UQ     [0, 1, ..., input-2, input-1]
      _       reverse
    jk        join on empty string
   <     Q    first (input) characters
          Q   the input again
++            concatenate everything so it prints on one line

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

— Doorknob
स्रोत

3

जाप, 13 बाइट्स

U+Uo w ¬¯U +U

इसे ऑनलाइन टेस्ट करें!

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

               // Implicit: U = input integer
  Uo           // Create the range [0..U).
     w         // Reverse.
       ¬       // Join.
        ¯U     // Slice to the first U chars.
U+         +U  // Append U on either end.

— ETHproductions
स्रोत

3

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

Ȯ’r0DFḣ³Ḍ³

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

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

Ȯ’r0DFḣ³Ḍ³  Main link. Input: n

Ȯ           Print n.
 ’          Decrement to yield n - 1.
  r0        Create a range from n - 1 to 0.
    D       Convert each integer to base 10 (array of decimal digits).
     F      Flatten the resulting array.
      ḣ³    Keep the first n elements.
        Ḍ   Convert from base 10 to integer.
         ³  Print the integer and set the return value to n.
            (implicit) Print the return value.

— डेनिस
स्रोत

3

रेटिना , 98 110

अब तक का सबसे लंबा उत्तर: - /

.+
$&;$&$*:
+`:(:+)$
$& $1
 (:)*
$#1
\d+$
$&0 $&0
T`d`,`\d+$
+`:(.*),
$1
+`. ,

(.+);(.*) 
$1$2$1

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

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

आप जावा को हरा सकते हैं!

— 13

2

विटसी, 35 बाइट्स

चूँकि विट्टी को इस बात की जानकारी नहीं है कि संख्याओं के तार कैसे बनाए जाते हैं, इसलिए मैंने दूसरी पंक्ति में दशमलव स्थानों में संख्या की लंबाई ज्ञात की।

V0VVNHVv[XDN1mv$-DvD);]VN
1a/+aL_1+

स्पष्टीकरण:

V0VVNHVv[XDN1mv$-DvD);]VN
V                          Save the input as a global final variable.
 0V                        Push 0, push input.
   VN                      Output the input.
     H                     Push the range 0...intput.
      Vv                   Push the input, then save it as a temp variable.
        [             ]    Do the stuff in brackets infinitely or until exited.
         X                 Remove the top item of the stack.
          DN               Duplicate, then pop as output.
            1m             Calls the first line index, retrieving length.
              v            Pop the temp var and push it to the stack.
               $           Switch the top two items of the stack. 
                -          Subtract them.
                 Dv        Duplicate, then pop one as a temp var.
                   D);     If it's zero, exit the loop.
                       VN  Output the global var.

1a/+aL_1+
1a/+       Add .1. This makes sure we don't throw errors on input 0.
    a      Push ten.
     L     Pop the top item as n, push the log base n of second to top.
      _    Make it an int.
       1+  Add 1.

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

शब्द के लिए वर्बोज़ मोड:

save top as permanent variable;
push 0;
save top as permanent variable;
save top as permanent variable;
output top as number;
push all ints between second to top and top;
save top as permanent variable;
save top as temporary variable;
begin recursive area;
remove top;
duplicate top item;
output top as number;
push 1;
goto top method;
save top as temporary variable;
switch the top two items;
subtract top two;
duplicate top item;
save top as temporary variable;
duplicate top item;
if (int) top is not 0;
generic exit;
end recursive area;
save top as permanent variable;
output top as number;
:push 1;
push 10;
divide top two;
add top two;
push 10;
push ln(top);
replace top with int(top);
push 1;
add top two;

— एडिसन क्रम्प
स्रोत

लगता है कि वर्बोज़ मोड इसकी परिभाषा में गलत है L, जिसे अब ठीक करना (हालांकि सवाल को अपडेट नहीं करेगा)।

— Addison Crump

बस जिज्ञासु, आप कार्यक्रम के अंत में विधि को निष्पादित करने से कैसे रोकते हैं? क्या न्यूलाइन वर्ण प्रोग्राम को वापस करने / बाहर निकलने का संकेत है?

— लीजनमोनमाल 978

@ LegionMammal978 कल्पना कीजिए कि प्रत्येक विटसी कार्यक्रम की पहली पंक्ति "मुख्य" विधि है, और अन्य सभी लाइनें public static voidविधियां हैं। मुख्य कार्यक्रम समाप्त होने पर समाप्त होता है। जैसा कि यह कैसे होता है, निर्देश एक प्रकार में आयोजित किए जाते हैं ArrayList<ArrayList<String[]>>, जहां प्रत्येक पंक्ति एक है String[]। हर विधि नईलाइन पर विभाजित होती है कि फाइल कैसे भरी जाती है, जिससे मुख्य विधि अन्य सभी तरीकों से अलग हो जाती है।

— Addison Crump

यह बताता है कि तीन स्तरों की आवश्यकता क्यों है। तो Strings निर्देश हैं, String[]s विधियां हैं (पहले एक मुख्य विधि है), और ArrayList<String[]>s वर्ग हैं (प्रथम एक मुख्य वर्ग है), सही है?

— लीजनमोनमाल 978

@ LegionMammal978 यह सब सही है। :)

— Addison Crump

2

शुद्ध बैश, 49

eval printf -va %s {$[$1-1]..0}
echo $1${a::$1}$1

या:

बैश + कोरुटिल्स, 48

echo $1$(seq $[$1-1] -1 0|tr -d \\n|head -c$1)$1

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

मुझे यकीन नहीं है कि ये रेंज का सही मूल्यांकन कर रहे हैं। परीक्षण में दोनों ही रेंज के केवल आधे भाग को प्रिंट करते हैं। यानी $ 1 = 90 के लिए, रेंज केवल 45 से नीचे है। मेरा प्रयास "$ i में (eval इको {$ 1..0}) के लिए था, इको-एन $ i; किया; इको $ 1"

— rcjohnson

@ आर्कजॉनसन मुझे लगता है कि आवश्यक व्यवहार है। क्या आप N = 90 के लिए आउटपुट की उम्मीद करते हैं?

— डिजिटल ट्रॉमा

@rcjohnson जैसे N = 12 के लिए, आउटपुट होना चाहिए 12, फिर 11..0(या 111098765432) के पहले 12 चार्ट , और फिर अंत में12

— डिजिटल ट्रॉमा

खैर विवरण को फिर से पढ़ने पर मुझे लगता है कि आप सही हैं। समस्या बताती है कि "स्पेस" पूर्णांक नहीं है।

— rcjohnson

@ आर्कजोनसन हां, मुझे लगता है कि "स्पेस" भाग केवल मध्यवर्ती चरणों पर लागू होता है। अंतिम आउटपुट अंकों का सिर्फ एक स्ट्रिंग होना चाहिए।

— डिजिटल ट्रॉमा

2

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

.+
$0,y$0$*y$0$*x
x
$'_
(x)*_
$#1
+`(y+)y(.)
$2$1
,(\d+).*
$1$`

अभी भी गोल्फ के लिए काफी कुछ जगह है ...

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

— randomra
स्रोत

हम्म, मैं बनाने के लिए विचार कर रहा हूँ $0में $0$*वैकल्पिक रूप में अच्छी तरह से, जब पूर्ववर्ती टोकन है एक शाब्दिक जो कार्य करता है (के रूप में अपने नहीं है yरों हैं) ... यह देख मैं वास्तव में लागू हो सकता है।

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

@ MartinBüttner मुझे लगा कि यह नई विशेषता है लेकिन वास्तव में नहीं है। :)

— यादृच्छिक

नहीं, वर्तमान में जो केवल प्रतिस्थापन की शुरुआत में काम करता है। उस ने कहा, हो सकता है कि आप उस का उपयोग करने के लिए पहले और अंतिम नंबर की भूमिकाओं को स्विच कर सकें?

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

2

MATL , 15 बाइट्स

VG:qPVXvG:)GVhh

EDIT (20 मई, 2016) लिंक में कोड भाषा के हालिया परिवर्तनों के कारण, के Xzबजाय उपयोग करता है Xv।

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

V                 % input n. Convert to string
 G:               % range [1,2,...,n]
   qP             % convert into [n-1,n-2,...,0]
     VXv          % convert to string, no spaces
        G:)       % take first n characters only
           GV     % push input as a string, again
             hh   % concat horizontally twice

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

1

जावा, 93 बाइट्स

String x(int v){String o=""+v;for(int i=v-1,c=o.length();o.length()-c<v;i--)o+=i;return o+v;}

— एडिसन क्रम्प
स्रोत

1

रूबी, 41 बाइट्स

->n{[n]*2*(r=0...n).to_a.reverse.join[r]}

— afuous
स्रोत

1

मिल्की वे 1.6.5 , 27 25 बाइट्स

I'::%{K£BCH=}<ΩHG<+<;+!

व्याख्या

I                        ` empty the stack
 '::                     ` push 3 copies of the input
    %{K£BCH=}            ` dump digits of reversed range(n) as strings [n-1...0]
             <ΩHG<+<;+   ` select the first nth digits and pad them with n
                      !  ` output

प्रयोग

$ ./mw <path-to-code> -i <input-integer>

— Zach गेट्स
स्रोत

मिल्की वे किस एन्कोडिंग का उपयोग करता है?

— अदनान

उह्ह्ह .. यूटीएफ -8, मुझे लगता है कि हाहा। @AndN

— Zach गेट्स

मुझे यह त्रुटि आई (हाँ, मैं एक विंडोज़ स्कंबैग: पी) हूं, जबकि इसे चलाने की कोशिश कर रहा हूं। मैंने इसे चिपकाया है: I'::%{K£BCH=}<OHG<+<;+!UTF-8 एन्कोडेड फ़ाइल में, लेकिन यह काम नहीं करता है।

— अदनान

यहाँ उस फ़ाइल का लिंक दिया गया है जिसका मैं उपयोग कर रहा हूँ। @AandN

— ज़ैक गेट्स

1

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

{$_~([R~] ^$_).substr(0,$_)~$_}

{
  $_ # input
  ~  # string concatenated with
  ([R~] ^$_)    # all numbers up to and excluding the input concatenated in reverse
  .substr(0,$_) # but use only up to the input number of characters
  ~
  $_
}

उपयोग:

for 2,3,7,12,100 {
  say {$_~([R~] ^$_).substr(0,$_)~$_}( $_ )
}

2102
32103
765432107
1211109876543212
1009998979695949392919089888786858483828180797877767574737271706968676665646362616059585756555453525150100

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

1

पर्ल, 43 + 2 = 45 बाइट्स

मुझे खुशी है कि मैंने इस्तेमाल नहीं किया reverseऔर न ही substr:

"@{[1-$_..0]}"=~s.\D..gr=~/.{$_}/;$_.=$&.$_

-plझंडे की आवश्यकता है ।

$ perl -ple'"@{[1-$_..0]}"=~s.\D..gr=~/.{$_}/;$_.=$&.$_' <<< 12
1211109876543212

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

                                            # '-p' read first line into `$_` and
                                            # auto print at the end
"@{[1-$_..0]}"                              # Create a list from -1-n..0 and
                                            # join it on space. This becomes:
                                            #   "-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0"
              =~s.\D..gr                    # Remove all but digits:
                                            #   "11109876543210"
                        =~/.{$_}/;          # Match the n first characters from
                                            # the generated string
                                  $_.=$&.$_ # Append the match and the input

— andlrc
स्रोत

1

सी, 130 125 बाइट्स

#define p(x) printf("%i",x);
i,y,h;f(x){for(i=y=x;(i-=h)>=0;){p(y--)h=floor(log10(y))+1;}if(i+=h)p(h=floor(y/pow(10,i)))p(x)}

Ungolfed संस्करण (स्पष्टीकरण के साथ):

#define p(x) printf("%i",x);     // alias to print an integer
i,y,h;                           // helper variables
f(x){                            // function takes an integer x as arg
    for(i=y=x;(i-=h)>=0;){       // i -> the remaining space
                                 // y -> the current descending number
        p(y--)                   // print y (at first y==x)
        h=floor(log10(y))+1;     // h -> the number of digits in y-1
    }                            // do it until there is no more empty space
    if(i+=h)                     // if needs to chop the last number
        p(h=floor(y/pow(10,i)))  // chop and print (implicitly cast of double to int)
    p(x)                         // print x at the end
}                                // end function

5 बाइट h=floor(...)की #define p(x)बचत के उपयोग की अनुमति देने के लिए अनुमानित रूप से दोहरे से int तक डाली गई ।

आइडोन पर टेस्ट।

— हटा दिया
स्रोत

1

आर, 67 बाइट्स (फ़ंक्शन के रूप में)

# usage example : f(7)
f=function(i)cat(i,substr(paste((i-1):0,collapse=''),1,i),i,sep='')

आर, 63 बाइट्स (एसटीडीआईएन से इनपुट)

i=scan();cat(i,substr(paste((i-1):0,collapse=''),1,i),i,sep='')

— digEmAll
स्रोत

1

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

यह केवल संख्या <10 के साथ काम करने वाला है

यहाँ गोल्फ संस्करण का प्रयास करें :

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

Ungolfed। इसे यहाँ आज़माएँ :

>
,
---------- Convert to base 10
----------
----------
----------
-------- 


[->+>+<<]>>[-<<+>>]<

Fill up the grid
[
[->+>+<<]>>[-<<+>>] //duplicate number like [5][0] -> [5][5]
<-
]

<[<]> Go to cell 1
[

>[>] Scan for zero
> Move one more
+ Add one
<< Move two back
[<] Scan for zero
> Move one forward
- Subtract One
]

> Move one forward into actual numbers
[
++++++++++ Convert to ascii
++++++++++
++++++++++
++++++++++
++++++++
.
>
]
++++++++++ Convert to ascii
++++++++++
++++++++++
++++++++++
++++++++
.
>
++++++++++ Convert to ascii
++++++++++
++++++++++
++++++++++
++++++++
.

— Keatinge
स्रोत

,>>++++++[<++++++++>-]<[-<->]<यह छोटे कोड की लंबाई के साथ 48 घटा सकता है

— लीक नून

यह रास्ता छोटा है ।

— लीक नून

यह और भी छोटा है।

— लीक नून

अवरोही अंक क्रम

परिचय

कार्य

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

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

व्याख्या

जूलिया, 30 बाइट्स

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

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

अजगर 2, 82 72 58 53 बाइट्स

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

जाप, 13 बाइट्स

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

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

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

रेटिना , 98 110

विटसी, 35 बाइट्स

शुद्ध बैश, 49

बैश + कोरुटिल्स, 48

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

MATL , 15 बाइट्स

जावा, 93 बाइट्स

रूबी, 41 बाइट्स

मिल्की वे 1.6.5 , 27 25 बाइट्स

व्याख्या

प्रयोग

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

उपयोग:

पर्ल, 43 + 2 = 45 बाइट्स

सी, 130 125 बाइट्स

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