Output integers in negative order, increase the maximum integer everytime

Question

Main task

Your task is to print out integers in descending order, starting from 1, and increasing as you keep hitting 1 again, up until the given input is reached, then, print out the rest until you hit 1 again. Example with input 6:

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

Side note: this is A004736 in the OEIS. Also, the first example (with newlines) is an invalid output, as specified in the rules.

Input

Your code may take any kind of input (graphical, STDIN) in the form of an integer or number.

Output

Your code should output the above described sequence, up until the input number is reached, then finish to output until it reaches 1 again. The output may be anything, therefore numbers, strings, integers, or graphical output. It is required to print out a single number (no newlines if it's a string). Your output can be in- and outroduced with as many characters as you need (e.g. []).

Since there was some misunderstanding, here's a regex pattern you can try your outputs on.

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

Rules

• The output must be a full number, not split up by anything, not even newlines.
• The algorithm shouldn't check for the first instance of N appearing in any way (e.g. the 21 in 121321), but rather for the first instance of N as the actual number.
• A single trailing newline is allowed.
• The handling for negative input is fully your choice, negative numbers aren't cases you should test.

Test cases

Input: 6
Output: 121321432154321654321


Input: 1
Output: 1

Input: 26
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0
Output: 0, Empty, or Error

Input: 21
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Thanks @Emigna, I used his algorithm to calculate these test cases.

Winner

The winner has been chosen! It was ErikGolfer's answer with an impressive 5 bytes! Congratulations!

Answer 1

Brachylog (v2), 7 bytes

⟦₁⟧₁ᵐcc

Try it online!

Function submission. (The TIO link contains a command-line argument to run a function as though it were a full program.)

This would be just five bytes if the sequences went down to 0 rather than 1 – so it seems that this is one of those questions that's decided by the choice of 0- versus 1-indexing.

Explanation

⟦₁⟧₁ᵐcc
⟦₁       Range from 1 to {the function input}
    ᵐ    On each element of that range,
  ⟧₁       take a descending range from that value to 1
     c   Concatenate the ranges
      c  Concatenate the digits of the resulting numbers

Answer 2

C#, 67 65 bytes

f=n=>{int x=n;var r="";while(n>0)r+=n--;return x>0?f(x-1)+r:"";};

Anonymous recursive function which returns the required string.

Full program with ungolfed method and test cases:

using System;

public class Program
{
    public static void Main()
    {
        Func<int, string> f = null;
        f = n =>
        {
            int x = n;
            var r = "";
            while (n > 0)
                r += n--;
            return x > 0 ? f(x - 1) + r : "";
        };

        Console.WriteLine(f(6));    // 121321432154321654321
        Console.WriteLine(f(1));    // 1
        Console.WriteLine(f(26));   // 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321
        Console.WriteLine(f(0));    // "" (empty string)
    }
}

Answer 3

PowerShell, 41 bytes

1..$args[0]|%{$a+=-join($_..1)};,$a-ne101

Try it online!

(7 bytes to handle the special case of 0 for input)

Loops from 1 up to the input $args[0], each iteration concatenates onto $a the result of a -join operation operating on the range from the current number $_ down to 1. Then, we turn $a into an array , and select those elements of the array that are -notequal to 101 (this filters out the 0 input). That's left on the pipeline and output is implicit.

NB -- Since strings in PowerShell (and .NET) are based on the StringBuilder class which is a char array, the maximum length we can get to is 2^31-1. But, PowerShell on your desktop will likely run out of memory before then, and TIO has an output limit of 256 KiB, so the actual maximum value supported is quite a bit smaller than that.

Answer 4

JavaScript, 53 bytes

f=(n,s='',x=n)=>{while(n)s+=n--;return x?f(--x)+s:''}

_{Thanks Titus for saving me bytes!}

Answer 5

Scala, 22 bytes

1 to _ map(_ to(1,-1))

Returns a sequence of sequences of ints.

Usage:

val f:(Int=>Seq[Seq[Int]])=1 to _ map(_ to(1,-1))
println(f(6))

Ungolfed:

n=>1 to n map(i=>i to 1 by -1)

Explanation:

1 to _      //create a Range from 1 to the argument of this function
map(        //map each element to...
  _ to(1,-1)  //a range from the number to 1, in steps of -1
)

Answer 6

bash, 69 bytes

f()([ $1 = 0 ]||(echo -n $1;f $[$1-1]));[ $1 = 0 ]||($0 $[$1-1];f $1)

f is a recursive function, and the entire script is recursive too.

Edit: @DigitalTrauma posted an improved version of this, which you can see in his comment on this answer. I'm not going to take the time to modify the answer, since he also posted a completely different bash solution, using brace expansion, that blows this answer away!

Answer 7

Mathematica, 38 54 bytes

FromDigits@*Flatten@IntegerDigits@Range[Range@#,1,-1]&

I stole Range[Range@#,1,-1] from Martin Ender's (still shorter) answer to save three bytes (dammit, I gotta start remembering that some functions are Listable). IntegerDigits converts the multi-digit numbers in the result to lists of single digits, Flatten removes all the list nesting, and FromDigits reassembles them into an integer. Oh well.

Answer 8

PHP, 52 49 bytes

<?for(;$k++<$argv[1]+2;$j=$k)while(--$j>0)echo$j;

Answer 9

Ruby, 37 34 bytes

->n{a=p;(1..n).map{|i|p a=[i,a]}*''}

Saved 3 bytes thanks to G B.

Answer 10

QBIC, 25 bytes

:[a|[b,1,-1|A=A+_t!c$|}?A

Sample run:

Command line: 10
12132143215432165432176543218765432198765432110987654321

Explanation:

:           Get 'a' from the command line
[a|         FOR b=1; b<=a; b++
[b,1,-1|      FOR c=b; c>=1; c--
A=A+_t!c$|      Append c to the 'output buffer' A$
}           Close the FOR loops
?A          Print 'a'

Non-competing: five minutes ago, I taught QBIC to do implicit printing on exit of anything stored in Z$. That brings the code for this challenge down to 22 bytes 19 bytes since I've made the cast-to-string autotrim!

:[a|[b,1,-1|Z=Z+!c$

Answer 11

Octave, 47 48 bytes

@(n)num2str((g=meshgrid(n:-1:1)')(g<=1:n)','%d')

Try it online!

Explanation:

meshgrid(n:-1:1)' :create a grid of repeated n:1

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

(g<=(1:n)) :only select those elements that are under anti-diagonal

   0   0   0   0   0   1
   0   0   0   0   1   1
   0   0   0   1   1   1
   0   0   1   1   1   1
   0   1   1   1   1   1
   1   1   1   1   1   1

Answer 12

W j f, 3 bytes

It's actually pretty trivial in W ...

M_M

Explanation

a      % Take an input, say 3
     M % Identity map every item in numeric value 3
       % Since it is prohibited, a range is generated,
       % namely [1 2 3]
 a M   % For every item in [1 2 3]:
       % Note that single items are 1, 2, and 3, *not* the whole list
  a    % Generate a range from 1 to that number: [[1] [1 2] [1 2 3]]
    _  % Reverse for lists: [[1] [2 1] [3 2 1]]

Flag:f % Flatten the list: [1 2 1 3 2 1]
Flag:j % Join the list: 121321
```

Answer 13

Keg, 11 bytes (SBCS)

Now I realized that Keg is pretty hard to use...

¿Ï_^'(Ï_')"

Try it online!

Answer 14

Vyxal, 5 bytes

ɾɾRṅṅ

Try it Online!

Tied with first :(

Explained

ɾɾRṅṅ
ɾɾ    # range of range of [1...input]
  R   # reduce (reverse each of list)
   ṅṅ # join by nothing twice

Answer 15

Python 2, 58 Bytes

print[[a for a in range(b+1,0,-1)]for b in range(input())]

Or, if the output of the above is not allowed, then the following code for 59 Bytes:

for i in range(input()+1):
 for j in range(i,0,-1):print j,

Answer 16

05AB1E, 6 bytes

LR.sJJ

Uses the CP-1252 encoding. Try it online!

         # Implicit input
 L       # Push [1, 2, ..., n]
  R      # Reverse
   .s    # Get suffixes
     JJ  # Join twice
         # Implicit output

Answer 17

Batch, 68 bytes

@for /l %%i in (1,1,%1)do @for /l %%j in (%%i,-1,1)do @cmd/cset/a%%j

Fortunately not printing newlines only costs 5 bytes.

Answer 18

Python, 80 bytes

r=''.join;lambda b:r([r([`i`for i in range(1,a+1)][::-1])for a in range(1,b+1)])

You can easily test this by pasting the above code into a repl and hitting enter, then typing _(6) or whatever input you want to give.

Answer 19

C, 52 bytes

Based on cat's existing answer:

i,j;f(n){j=++i;while(j)printf("%d",j--);i-n?f(n):0;}

Call with:

int main()
{
    f(6);
}

Answer 20

Java: 141 chars

void c(int in,StringBuilder s){for(int i=1;i<=in;i++){for(int j=i;j>0;j--){s.append(Integer.toString(j));}}System.out.println(s.toString());}

Using c(6,new StringBuilder());:

121321432154321654321

Answer 21

Clojure, 94 84 74 bytes

-10 bytes by eliminating the redundant for.

-10 bytes by eliminating the let.

Still long, but -20 bytes is nice.

#(loop[r 1 a""](if(> r %)a(recur(inc r)(str a(apply str(range r 0 -1))))))

Generates the reversed range, and concats it to the accumulator, then loops again while necessary.

Ungolfed:

(defn negative-order [n]
  (loop [r 1
         a ""]
    (let [s (apply str (range r 0 -1))]
      (if (> r n)
        a
        (recur (inc r) (str a s))))))

Answer 22

Clojure, 57 bytes

#(apply str(reductions(fn[s i](str(inc i)s))""(range %)))

reductions is perfect for incrementally producing outputs like this.

Answer 23

Stacked, noncompeting, 20 bytes

~>~>reveach flat''#`

Try it online!

I think a few of the features used in this answer were made after this challenge.

Explanation

~>~>reveach flat''#`
~>                    range from [1, n]
  ~>                  vectorized range [[1,1], [1,2], ..., [1, n]]
    reveach           reverses each segment
            flat      flatten
                ''#`  join by nothing

Answer 24

Java, 99 bytes

void f(int a){int[]f=new int[2];while(++f[0]<=a){f[1]=f[0];while(f[1]>0)System.out.print(f[1]--);}}

EDIT 1: Saved few bytes by changing it from a full program to a function.

Ungolfed:

void f(int a) {
    int[] f = new int[2];
    while (++f[0] <= a) {
        f[1] = f[0];
        while (f[1] > 0) System.out.print(f[1]--);
    }
}

Answer 25

GolfScript, 12 bytes

~),(;{),(;}%

Try it online!

Answer 26

Japt -P, 5 bytes

õõ cÔ

Try it

õõ cÔ     :Implicit input of integer
õ         :Range [1,input]
 õ        :Range [1,each], giving a 2D-array
   c      :Flatten after
    Ô     :Reversing each
          :Implicitly join & output

Answer 27

Thunno 2 N, 3 bytes

RRṃ

Attempt This Online!

Same as Reversed Iota's, but with the N flag which joins the nested list.