Reversed Iota's

Question

I didn't invent this challenge, but I find it very interesting to solve.

For every input number, e.g.:

4

Generate a range from 1 to that number:

[1 2 3 4]

And then, for every item in that list, generate a list from 1 to that number:

[[1] [1 2] [1 2 3] [1 2 3 4]]

Then, reverse every item of that list.

[[1] [2 1] [3 2 1] [4 3 2 1]]

Notes:

• 1 being a loose item is allowed, since flattening will not matter with this anyway.
• To preserve the spirit of the challenge, the range has to be 1-indexed.
• You may flatten the list if your platform doesn't support the concept of nested lists.

Answer 1

APL (Dyalog Unicode), 5 4 bytes^SBCS

Anonymous tacit prefix function.

,⍨\⍳

Try it online!

,⍨\ cumulative reverse-concatenation reduction of

⍳ the iota

Answer 2

R, 22 19 bytes

Map(`:`,1:scan(),1)

Try it online!

Map(f,...) applies f elementwise to each member of ..., recycling as needed, resulting in a list, so we just supply 1 as the to argument to : to get the reversed.

-3 bytes thanks to Vlo!

Answer 3

Jelly, 3 bytes

RRU

R     Range from 1 to input
 R    (implicitly) map over said range and create a range from 1 to this element
  U   reverse each of those

You can try it online!

Courtesy of @JonathanAllan, we also have two other 3-"byters"

RrL
RrE

I think it is not often that golfing languages solve a challenge with only a-zA-Z characters

Answer 4

Pure Bash (no external utilities), 29

eval eval echo \\{{1..$1}..1}

Try it online!

Answer 5

05AB1E, 3 bytes

LLí

Try it online!

Answer 6

shell + sed, 15 bytes

seq $1|sed G\;h

Try it online!

Outputs like so, 1\n\n2\n1\n\n3\n2\n1\n\n[...]

seq $1 creates a sequence from 1 to the first argument $1

|sed ... which is piped into a sed script

sed works on a line-by-line basis; it first reads the first line into the buffer, called the "pattern space", after which the program commands is run on it. At the end of the program's execution on the first line, the remaining pattern space is implicitly printed. Then sed reads the next line into the pattern space, replacing the previous contents, and runs the commands on it, repeating for all lines of input (unless a command specifies otherwise).

The pattern space is not saved between lines, but what is is the hold space. The hold space is another buffer, that starts empty, and can be modified by program commands. Its contents are carried on to the execution of the next line of input.

The G command appends a newline followed by the content of the hold space to that of the pattern space. Then the h command replaces the hold space with the content of the pattern space. This effectively reverses the lines of input encountered so far, writing them to the pattern space – implicitly printing at the end of processing the current line – and saving them to the hold space so that upon reading subsequent lines of input, the new reversed "list" can be constructed with G;h.

The ; is escaped in the program as \; because otherwise the shell interprets it as terminating a shell command.

Answer 7

Perl 6 Raku, 24 15 13 10 bytes

-2 removed parenthesis

-3 thanks to nwellnhof

^*+1 X…1

Try it online!

Explanation

^*+1     # make a range from 1 .. argument (whatever star).
     X…1 # create ranges descending to 1 using cross product metaoperator.

Previous version, 24 bytes

(^<<(^*+1)X+1)>>.reverse

Try it online!

Explanation

     ^*+1                # make a range from 1 .. argument (whatever star)
 ^<<(    )               # replace each element with a range from 0 .. element - 1
                         # (via hyper prefix operator)
          X+1            # shift the range to 1 .. element
                         # (via cross product metaoperator)
(            )>>.reverse # reverse each list (via hyper method operator)

Answer 8

K (ngn/k), 8 bytes

|',\1+!:

Try it online!

-2 thanks to ngn :-)

Answer 9

Wolfram Language (Mathematica), 20 bytes

Range[Range@#,1,-1]&

Try it online!

-3 bytes from @att

Answer 10

JavaScript (ES6),  50  49 bytes

Saved 1 byte thanks to @Shaggy

f=n=>n?[...f(n-1),(g=_=>n?[n,...g(--n)]:[])()]:[]

Try it online!

Answer 11

PHP, 54 bytes

function($x){for(;$y<$x;$a[]=range(++$y,1));return$a;}

Try it online!

Or recursive:

PHP, 54 bytes

function f($x){return$x?f($x-1)+[$x=>range($x,1)]:[];}

Try it online!

Or with PHP-formatted printed output:

PHP, 38 bytes

for(;$x<$argn;print_r(range(++$x,1)));

Try it online!

Answer 12

Raku, 13 bytes

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

Try it online!

Cumulative reverse with the range 1 to input.

Answer 13

x86-16 machine code, 12 bytes

Binary:

00000000: 33c0 4050 ab48 75fc 58e2 f7c3         [email protected]...

Unassembled listing:

33 C0       XOR  AX, AX         ; AX = 0
        OUT_LOOP:
40          INC  AX             ; start at 1
50          PUSH AX             ; save starting position
        IN_LOOP:
AB          STOSW               ; write to output buffer, increment DI
48          DEC  AX             ; AX--
75 FC       JNZ  IN_LOOP        ; if AX > 0, keep looping
58          POP  AX             ; restore starting position
E2 F7       LOOP OUT_LOOP 
C3          RET                 ; return to caller

Input Number in CX, output array of WORD, at [DI].

Example I/O using DOS test driver program:

Answer 14

BQN, 10 bytes

Anonymous tacit prefix function.

(⌽1+↕)¨1+↕

Try it online!

Explanation

(⌽1+↕)¨1+↕
       1+↕    1.  Get list of integers from 1 to n.
      ¨       2a. For each integer i in the list...
( 1+↕)        2b. get a list of integers from 1 to i...
(⌽   )        2c. and then reverse that list.

Answer 15

PowerShell, 19 bytes

1.."$args"|%{$_..1}

Try it online!

Generates the range from 1 to input $args, then constructs the reversed range for each of those numbers. Tack on a -join to better see how the arrays are created (because PowerShell inserts a newline between each element, it's tough to see the individual arrays).

Answer 16

Python 3, 46 bytes

lambda n:[[*range(i+1,0,-1)]for i in range(n)]

Try it online!

Answer 17

GolfScript, 12 (13) bytes

,{)),(;-1%}%`

,{)),(;-1%}%` #Reversed iota of iota
,             #0 to n-1 iota
 {        }%  #For each element in the iota
 {))      }   #Increment by 2
 {  ,     }   #Iota
 {   (;   }   #Pop leading 0
 {     -1%}   #Reverse it
            ` #Pretty output, not needed if you use a better stack-interpreter

Try it online!

Below is my old solution, I gained inspiration after posting and improved it.

),(;{),(;-1%}%`

Comma is the function that builds an array 0 to n-1, "iota expand".

),(;{),(;-1%}%` #Take in a number, output reversed expanded iota
)               #Increment input by 1
 ,              #Iota expand
  (;            #Remove leading 0
    {       }%  #For every element, do the following
    {)      }   #Increment by 1
    { ,     }   #Iota expand
    {  (;   }   #Remove leading 0
    {    -1%}   #Reverse
              ` #Pretty output; technically not needed

Try it online!

Answer 18

Factor, 45 bytes

: f ( n -- s ) [1,b] [ 1 [a,b] >array ] map ;

Try it online!

Answer 19

Ruby, 34 30 bytes

->n,*a{(1..n).map{|x|a=[x]+a}}

Try it online!

Thanks Value Ink (as usual) for -4 bytes.

Answer 20

Haskell, 27 bytes

f n=scanl(flip(:))[1][2..n]

Answer 21

Zsh, 22 bytes

eval echo {{1..$1}..1}

Try it online!

{{1..$1}..1} -> {1..1} {2..1} {3..1} {4..1} ...

eval echo {1..1} {2..1} {3..1} ... -> echo 1 2 1 3 2 1 ...

If the sublists must be delimited, then 25 bytes for , or 26 bytes for newline.

Answer 22

Fortran (GFortran), 47 bytes

read*,i
print*,("{",(j,j=k,1,-1),"}",k=1,i)
end

Try it online!

Could remove 8 chars by getting rid of printed brackets if anyone would believe that they are lists otherwise.

Answer 23

Elm, 45 bytes

r=List.range 1
f=List.map(List.reverse<<r)<<r

Try it on Ellie

Answer 24

Arturo, 22 18 bytes

$=>[map&=>[@&..1]]

Try it

Answer 25

Brachylog, 5 bytes

⟦₁⟧₁ᵐ

Try it online!

Explanation

⟦₁     Ascending range from 1 to the input
    ᵐ  Map:
  ⟧₁     Descending range from 1 to the mapped element

Answer 26

Haskell, 74 73 51 bytes

main=do i<-getLine;print[[x,x-1..1]|x<-[1..read i]]

Try it online!

-22 bytes thanks to @79037662

Answer 27

Burlesque, 9 bytes

riroq<-pa

Try it online!

ri  # Read int
ro  # Range [1,N]
q<- # Boxed reverse
pa  # Operate over ((1), (1 2), (1 2 3),...)

Alternative 9 byter, but this also has an empty list as the first element:

riroiT)<-

Answer 28

Go, 105 bytes

func(n int)(o[][]int){for i:=1;i<=n;i++{J:=[]int{}
for j:=i;j>0;j--{J=append(J,j)}
o=append(o,J)}
return}

Attempt This Online!

Answer 29

shell with seq loop, 46 bytes

for n in `seq $1`;do seq -s\  -t'\n' $n 1;done

Answer 30

JavaScript, 60 bytes

Without recursion:

n=>eval('for(a=[];n;a[--n]=b)for(b=[j=n];j-->1;b[n-j]=j);a')

Try it:

f=n=>eval('for(a=[];n;a[--n]=b)for(b=[j=n];j-->1;b[n-j]=j);a')

console.log(JSON.stringify(f(1)));
console.log(JSON.stringify(f(2)));
console.log(JSON.stringify(f(3)));
console.log(JSON.stringify(f(4)));