Given an input, print all exponents where the base and power sum to the input

Question

So this is my first challenge on this site.

The challenge is to take in an input integer \$n\$, which will be positive, and print, in ascending order (\$1\$ to \$n\$, including n), the output of \$i^{(n-i)}\$ (where \$i\$ is the current integer).

Example

Given the input 5, the program will print:

1  
8  
9  
4  
1  

\$1^4\$ is 1 and \$1+4=5\$
\$2^3\$ is 8 and \$2+3=5\$
\$3^2\$ is 9 and \$3+2=5\$
\$4^1\$ is 4 and \$4+1=5\$
\$5^0\$ is 1 and \$5+0=5\$

Input and Output

Input will be in the form of a positive integer. Output will be a list of numbers, delimited by either commas or new lines.

This is code-golf, so shortest code wins.

Answer 1

APL (Dyalog Unicode), 8 5 bytes

⍳*⊢-⍳

Try it online!

Anonymous prefix tacit function. TIO tests for the range [1..10].

Thanks @lirtosiast for 3 bytes.

How:

⍳*⊢-⍳ ⍝ Tacit function
    ⍳ ⍝ Range. ⍳n generates the vector [1..n].
  ⊢- ⍝ Subtracted from the argument. The vector is now [n-1,n-2,...,0]
⍳*    ⍝ Exponentiate using the range [1..n] as base. The result is the vector
      ⍝ [1^(n-1), 2^(n-2), 3^(n-3),...]

Answer 2

Perl 6, 19 bytes

{^$_+1 Z**[R,] ^$_}

Try it online!

Anonymous code block that takes a number and returns a list. Zip exponents the range 1 to input and the range input-1 to 0

Answer 3

Haskell, 23 bytes

f i=[x^(i-x)|x<-[1..i]]

Try it online!

Alternative version, also 23 bytes:

f i=(^)<*>(i-)<$>[1..i]

Answer 4

Aheui (esotope), 193 164 bytes (56 chars)

방빠싹받분샥퍼붇바파쟈뿌차샦히망맣여
타빠바푸투반또분뽀뿌서썪삯타삯받반타
석차샦져쌲볼어타토싻삭빠쏛ㅇ또섞썪뻐

Try it online!

Try it on AVIS(Korean); just copy and paste code above, press start button, input a number, see how it moves. To see output, press the >_ icon on left side.

---

It's not golfed much, but I give it a shot.

Answer 5

Japt, 5 bytes

õ_p´U

Try it

õ         :Range [1,input]
 _        :Map
  p       :  Raise to the power of
   ´U     :  Input decremented

Answer 6

Pyth, 5 bytes

_m^-Q

Try it online!

Optimally encoded this would be 4.106 bytes.

_                reverse of the following list:
 m               map the following lambda d:
  ^                (N-d)**d
   -Qd             
      d
       Q         over [0,...,N-1]

Answer 7

J, 10 bytes

(>:^|.)@i.

Try it online!

If we really need to separate the numbers by a newline:

J, 13 bytes

,.@(>:^|.)@i.

Try it online!

Answer 8

Jelly, 5 bytes

R*ḶU$

Try it online!

R                [1,...,n]
 *               to the power of
  ḶU$            [0,...,n-1] reversed

Answer 9

Octave, 18 bytes

@(n)(t=1:n).^(n-t)

Try it online!

Thanks Luis Mendo, using internal variable saves 3 bytes.

Answer 10

PHP, 32 bytes

while($argn)echo++$i**--$argn,_;

Run as pipe with -nR or try it online.

Answer 11

Jelly, 4 bytes

*ạ¥€

Try it online!

Answer 12

JavaScript (Node.js), 33 32 bytes

n=>(g=i=>--n?++i**n+[,g(i)]:1)``

Try it online!

-3 bytes with credits to @Shaggy, and -1 byte by @l4m2!

JavaScript (Node.js), 36 bytes

f=(n,i=1)=>n--?[i++**n,...f(n,i)]:[]

Try it online!

JavaScript (Node.js), 37 bytes

n=>[...Array(n)].map(x=>++i**--n,i=0)

Try it online!

Answer 13

Wolfram Language (Mathematica), 24 20 18 bytes

(x=Range@#)^(#-x)&

Try it online!

-4 thanks @lirtosiast.

Answer 14

MathGolf, 6 bytes

rx\╒m#

Try it online!

Answer 15

Python 2, 40 bytes

lambda n:[i**(n-i)for i in range(1,n+1)]   #Outputs a list

Try it online!

Python 2, 41 bytes

n,i=input(),0
exec"print(n-i)**i;i+=1;"*n   #Prints in reversed order

Try it online!

Answer 16

Ruby, 27 bytes

->n{(1..n).map{|r|r**n-=1}}

Try it online!

Answer 17

QBasic, 3533 bytes

Thank you @Neil for 2 bytes!

INPUT a
FOR b=1TO a
?b^(a-b)
NEXT

Slightly expanded version on REPL.IT because the interpreter in't entirely up-to-spec.

Output

QBasic (qb.js)
Copyright (c) 2010 Steve Hanov

   5
1
8
9
4
1

Answer 18

Retina, 35 bytes

.+
*
_
$$.($.'*$($.>`$*)_¶
%~`^
.+¶

Try it online! Explanation:

.+
*

Convert the input to unary.

_

Match each position. This then sets several replacement variables. $` becomes the left of the match; $>` modifies this to be the left and match; $.>` modifies this to take the length, i.e. the current index. $' meanwhile is the right of the match, so $.' is the length i.e. the current exponent.

$$.($.'*$($.>`$*)_¶

Create a string $.( plus $.' repetitions of $.>`* plus _. For an example, for an index of 2 in an original input of 5, $.' is 3 and $.>` is 2 so the resulting string is $.(2*2*2*_. This conveniently is a Retina replacement expression that caluclates 2³. Each string is output on its own line.

%~`^
.+¶

For each line generated by the previous stage, prefix a line .+ to it, turning it into a replacement stage, and evaluate that stage, thereby calculating the expression.

Answer 19

F# (.NET Core), 42 bytes

let f x=Seq.map(fun y->pown y (x-y))[1..x]

Try it online!

Answer 20

Java, 59 Bytes

for(int i=1;a+1>i;i++)System.out.println(Math.pow(i,a-i));

Answer 21

C# (Visual C# Interactive Compiler), 46 bytes

x=>new int[x].Select((_,i)=>Math.Pow(i+1,--x))

Try it online!

Answer 22

MATL, 5 bytes

:Gy-^

Try it online!

Explanation

Consider input 5 as an example.

:     % Implicit input. Range
      % STACK: [1 2 3 4 5]
G     % Push input again
      % STACK: [1 2 3 4 5], 5
y     % Duplicate from below
      % STACK: [1 2 3 4 5], 5, [1 2 3 4 5]
-     % Subtract, element-wise
      % STACK: [1 2 3 4 5], [4 3 2 1 0]
^     % Power, element-wise. Implicit display
      % STACK: [1 8 9 4 1]

Answer 23

Clean, 37 bytes

import StdEnv
$n=[i^(n-i)\\i<-[1..n]]

Try it online!

Defines $ :: Int -> [Int] taking an integer and returning the list of results.

$ n                // function $ of n
 = [i ^ (n-i)      // i to the power of n minus i
    \\ i <- [1..n] // for each i in 1 to n
   ]

Answer 24

R, 34 bytes

x=1:scan();cat(x^rev(x-1),sep=',')

Try it online!

Answer 25

Lua, 43 41 bytes

-2 bytes thanks to @Shaggy

s=io.read()for i=1,s do print(i^(s-i))end

Try it online!

Answer 26

05AB1E, 5 bytes

LD<Rm

Port of @lirtosiast's Jelly answer.

Try it online.

Explanation:

L      # List in the range [1, (implicit) input integer]
       #  i.e. 5 → [1,2,3,4,5]
 D<    # Duplicate this list, and subtract 1 to make the range [0, input)
       #  i.e. [1,2,3,4,5] → [0,1,2,3,4]
   R   # Reverse it to make the range (input, 0]
       #  i.e. [0,1,2,3,4] → [4,3,2,1,0]
    m  # Take the power of the numbers in the lists (at the same indices)
       # (and output implicitly)
       #  i.e. [1,2,3,4,5] and [4,3,2,1,0] → [1,8,9,4,1]

Answer 27

R, 22 bytes

n=scan();(1:n)^(n:1-1)

Fairly self-explanatory; note that the : operator is higher precendence than the - operator so that n:1-1 is shorter than (n-1):0

If we are allowed to start at 0, then we can lose two bytes by using (0:n)^(n:0) avoiding the need for a -1.

Answer 28

Charcoal, 9 bytes

Ｉ⮌ＥＮＸ⁻θιι

Try it online! Link is to verbose version of code. Explanation:

   Ｎ        Input as a number
  Ｅ         Map over implicit range
       ι    Current value
     ⁻      Subtracted from
      θ     First input
    Ｘ       Raised to power
        ι   Current value
 ⮌          Reverse list
Ｉ           Cast to string
             Implicitly print on separate lines

Answer 29

C# (Visual C# Interactive Compiler), 55 bytes

v=>Enumerable.Range(0,v--).Select(i=>Math.Pow(i+1,v--))

Try it online!

Answer 30

C++ (clang), 80 bytes, 71 bytes, 63 bytes, 59 bytes, 56 bytes

int n,c=1;cin>>n;for(;c<=n;++c){cout<<pow(c,n-c)<<endl;}

Try it online!

Answer 31

Perl 5 -n, 21 bytes

say++$\**--$_ while$_

Try it online!

Answer 32

Pari/GP, 22 bytes

n->[i^(n-i)|i<-[1..n]]

Try it online!

Answer 33

PowerShell, 39 bytes

param($n)1..$n|%{"1"+"*$_"*($n-$_)|iex}

Try it online!

Because exponents are expensive in Powershell, this works by using invoke-expression to parse and calculate the string "1*n*n...*n" Works because the first and last entry are always 1.

Answer 34

Gambit Scheme (gsi), 52 bytes

(lambda(x)(map(lambda(y)(expt y(-x y)))(iota x 1)))

For some reason this code does not appear to work on TIO. It works fine on my machine.

Explanation:

(lambda(x)(map(lambda(y)(expt y(- x y)))(iota x 1)))    Full program
(lambda(x)                                        )    Anonymous function with arg x
          (map(lambda(y)              )(iota x 1))     Map over the range 1 to input
                        (expt y                        Raises the mapped value to...
                               (- x y)                 The input value minus the mapped value (this powers the list by the reverse)

Answer 35

C (gcc) (-lm), 52 bytes

f(n,i){for(i=n;i--;printf("%.0f\n",pow(n-i,i)));}

Try it online!

Answer 36

APL(NARS), 11 chars, 22 bytes

{⍪⍵*⌽⍵-1}∘⍳

test:

  f←{⍪⍵*⌽⍵-1}∘⍳
  f 5
1
8
9
4
1

Answer 37

SAS, 71 bytes

data a;input n;o=cat(1);do x=1 to n-1;o=catx(',',(n-x)**x,o);end;cards;

Input goes after the cards; statement, separated by newlines, like so:

data a;input n;o=cat(1);do x=1 to n-1;o=catx(',',(n-x)**x,o);end;cards;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Outputs a dataset containing the input n, and comma-separated output string o (and also helper variable x)

+----+------------------------------------------------------------------------------------------+----+
| n  |                                            o                                             | x  |
+----+------------------------------------------------------------------------------------------+----+
¦ 1  ¦ 1                                                                                        ¦ 1  ¦
¦ 2  ¦ 1,1                                                                                      ¦ 2  ¦
¦ 3  ¦ 1,2,1                                                                                    ¦ 3  ¦
¦ 4  ¦ 1,4,3,1                                                                                  ¦ 4  ¦
¦ 5  ¦ 1,8,9,4,1                                                                                ¦ 5  ¦
¦ 6  ¦ 1,16,27,16,5,1                                                                           ¦ 6  ¦
¦ 7  ¦ 1,32,81,64,25,6,1                                                                        ¦ 7  ¦
¦ 8  ¦ 1,64,243,256,125,36,7,1                                                                  ¦ 8  ¦
¦ 9  ¦ 1,128,729,1024,625,216,49,8,1                                                            ¦ 9  ¦
¦ 10 ¦ 1,256,2187,4096,3125,1296,343,64,9,1                                                     ¦ 10 ¦
¦ 11 ¦ 1,512,6561,16384,15625,7776,2401,512,81,10,1                                             ¦ 11 ¦
¦ 12 ¦ 1,1024,19683,65536,78125,46656,16807,4096,729,100,11,1                                   ¦ 12 ¦
¦ 13 ¦ 1,2048,59049,262144,390625,279936,117649,32768,6561,1000,121,12,1                        ¦ 13 ¦
¦ 14 ¦ 1,4096,177147,1048576,1953125,1679616,823543,262144,59049,10000,1331,144,13,1            ¦ 14 ¦
¦ 15 ¦ 1,8192,531441,4194304,9765625,10077696,5764801,2097152,531441,100000,14641,1728,169,14,1 ¦ 15 ¦
+----------------------------------------------------------------------------------------------------+

Answer 38

C (clang), 47 bytes

i;f(a){for(i=a;i;printf("%.f,",pow(i,a-i--)));}

Try it online!

Prints in reverse order, delimited with commas.