[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](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code wins.
  
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~8~~ 5 bytes
```
⍳*⊢-⍳
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT/@v8ahvql/wo941mnogZrCrXqizr4t6Un6FQn6egm6abX6e@qOuxal5iUk5qcGOPiFADlCdc6R6cWJOibomF5Dj6f@obYLB/0c9ex91zHjUu1nrUe8KQ20g438aUOJRbx9ETVfzofXGj9omgqwJcgaSIR6ewf8f9a5KOwRRbmgAAA "APL (Dyalog Unicode) – 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]
## Haskell, 23 bytes
```
f i=[x^(i-x)|x<-[1..i]]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00h0za6Ik4jU7dCs6bCRjfaUE8vMzb2f25iZp6CrUJBUWZeiYKKQpqC6X8A "Haskell – Try It Online")
Alternative version, also 23 bytes:
```
f i=(^)<*>(i-)<$>[1..i]
```
[Answer]
# Japt, 5 bytes
```
õ_p´U
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=9V9wtFU=&input=OA==)
```
õ         :Range [1,input]
 _        :Map
  p       :  Raise to the power of
   ´U     :  Input decremented
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 19 bytes
```
{^$_+1 Z**[R,] ^$_}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwvzpOJV7bUCFKSys6SCdWAcir/Z@WX6RgqmOpY2isUM3FWZxYqaCnlsZV@x8A "Perl 6 – 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]
# [Aheui (esotope)](https://github.com/aheui/pyaheui), ~~193~~ 164 bytes (56 chars)
```
방빠싹받분샥퍼붇바파쟈뿌차샦히망맣여
타빠바푸투반또분뽀뿌서썪삯타삯받반타
석차샦져쌲볼어타토싻삭빠쏛ㅇ또섞썪뻐
```
[Try it online!](https://tio.run/##JY7BCoJAFEX3/k8f1CKoD2gvOqXQSAZRgmlClBVGQ4UoGn1My/vmG6Y3tHlcePcc7nA8mk6MgbqgLWjRQqWoBflHHfWoA6i1lpL2IT6S1Jn8k85DlBnKA20rR/suY7a0anRYQSVIYubxdi0gdhRdybtzja9Vq4SzQyL7y6hoSD7w7Gnz4oee84SOvJvdsky/s4B1JHK2oIuNGfwA "Aheui (esotope) – Try It Online")
[Try it on AVIS](https://aheui.github.io/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]
# [Pyth](https://github.com/isaacg1/pyth), 5 bytes
```
_m^-Q
```
[Try it online!](https://tio.run/##K6gsyfj/Pz43Tjfw/39TAA "Pyth – 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]
# [J](http://jsoftware.com/), 10 bytes
```
(>:^|.)@i.
```
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8F/DziquRk/TIVPvvyaXkp6CepqtnrqCjkKtlUJaMRdXanJGvkKagimMYQJjGBr8BwA "J – Try It Online")
## If we really need to separate the numbers by a newline:
# [J](http://jsoftware.com/), 13 bytes
```
,.@(>:^|.)@i.
```
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8F9Hz0HDziquRk/TIVPvvyaXkp6CepqtnrqCjkKtlUJaMRdXanJGvkKagimEoa6rq6sOEzPBImZo8B8A "J – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
R*ḶU$
```
[Try it online!](https://tio.run/##y0rNyan8/z9I6@GObaEq////NwUA "Jelly – Try It Online")
```
R                [1,...,n]
 *               to the power of
  ḶU$            [0,...,n-1] reversed
```
[Answer]
# PHP, 32 bytes
```
while($argn)echo++$i**--$argn,_;
```
Run as pipe with `-nR` or [try it online](http://sandbox.onlinephpfunctions.com/code/0c987739bbeb6317fc43a8a63bcbabdf4ce0f4e8).
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 18 bytes
```
@(n)(t=1:n).^(n-t)
```
[Try it online!](https://tio.run/##y08uSSxL/f/fQSNPU6PE1tAqT1MvTiNPt0Tzf5ptYl4xV5qGqeZ/AA "Octave – Try It Online")
Thanks [Luis Mendo](https://codegolf.stackexchange.com/users/36398/luis-mendo), using internal variable saves 3 bytes.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
*ạ¥€
```
[Try it online!](https://tio.run/##y0rNyan8/1/r4a6Fh5Y@alrz//9/UwA "Jelly – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~24~~ ~~20~~ 18 bytes
```
(x=Range@#)^(#-x)&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE7872Zl@1@jwjYoMS891UFZM05DWbdCU@1/QFFmXkm0W7RpbOx/AA "Wolfram Language (Mathematica) – Try It Online")
-4 thanks @lirtosiast.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 6 bytes
```
rx\╒m#
```
[Try it online!](https://tio.run/##y00syUjPz0n7/7@oIubR1Em5yv//m3JZchkaAwA "MathGolf – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 40 bytes
```
lambda n:[i**(n-i)for i in range(1,n+1)]   #Outputs a list
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPKjpTS0sjTzdTMy2/SCFTITNPoSgxLz1Vw1AnT9tQM/Z/QVFmXolCmoapJheMaYJgGiIxDTT/AwA "Python 2 – Try It Online")
# [Python 2](https://docs.python.org/2/), 41 bytes
```
n,i=input(),0
exec"print(n-i)**i;i+=1;"*n   #Prints in reversed order
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P08n0zYzr6C0RENTx4ArtSI1WamgKDOvRCNPN1NTSyvTOlPb1tBaSSvv/39TAA "Python 2 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 27 bytes
```
->n{(1..n).map{|r|r**n-=1}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vWsNQTy9PUy83saC6pqimSEsrT9fWsLb2f4FCWrRpLBeIMjSM/Q8A "Ruby – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 35 bytes
```
.+
*
_
$$.($.'*$($.>`$*)_¶
%~`^
.+¶
```
[Try it online!](https://tio.run/##K0otycxLNPz/X0@bS4srnktFRU9DRU9dSwVI2iWoaGnGH9rGpVqXEMelp31o2///pgA "Retina – 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]
## QBasic, ~~35~~33 bytes
Thank you @Neil for 2 bytes!
```
INPUT a
FOR b=1TO a
?b^(a-b)
NEXT
```
Slightly expanded version on [REPL.IT](https://repl.it/@pimsteenbergh/MasculineDarksalmonApplicationpackage) 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]
# [F# (.NET Core)](https://www.microsoft.com/net/core/platform), 42 bytes
```
let f x=Seq.map(fun y->pown y (x-y))[1..x]
```
[Try it online!](https://tio.run/##SyvWTc4vSv3/Pye1RCFNocI2OLVQLzexQCOtNE@hUteuIL8cSCtoVOhWampGG@rpVcT@LyjKzCtJy1NQUnVUUtAAaSjJ98ksLtFIUzDV1PwPAA "F# (.NET Core) – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~33~~ 32 bytes
```
n=>(g=i=>--n?++i**n+[,g(i)]:1)``
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/P1k4j3TbT1k5XN89eWztTSytPO1onXSNTM9bKUDMh4b91cn5ecX5Oql5OfrpGmoappuZ/AA "JavaScript (Node.js) – Try It Online")
-3 bytes with credits to @Shaggy, and -1 byte by @l4m2!
# [JavaScript (Node.js)](https://nodejs.org), 36 bytes
```
f=(n,i=1)=>n--?[i++**n,...f(n,i)]:[]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYjTyfT1lDT1i5PV9c@OlNbW0srT0dPTy8NJKEZaxUd@986OT@vOD8nVS8nP10jTcNUU/M/AA "JavaScript (Node.js) – Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 37 bytes
```
n=>[...Array(n)].map(x=>++i**--n,i=0)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/P1i5aT0/PsagosVIjTzNWLzexQKPC1k5bO1NLS1c3TyfT1kDzv3Vyfl5xfk6qXk5@ukaahqmm5n8A "JavaScript (Node.js) – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 46 bytes
```
x=>new int[x].Select((_,i)=>Math.Pow(i+1,--x))
```
[Try it online!](https://tio.run/##DcqxCsIwEADQvV9xdEowCTg4tc2moCgIHRxEpMarHtQLpAnN38dOb3lu1m6mckjsWuKo4Ljn9MMwvCZs3z6tWAsjdFByZxkXWNc9P0yPE7ooxFOR7OxliF9z9YugzVZpnaUsTVXdAkU8E6PoYyD@mJMnFjXUCkaxk1I25Q8 "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
```
:Gy-^
```
[Try it online!](https://tio.run/##y00syfn/38q9Ujfu/39TAA "MATL – 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]
# Java, 59 Bytes
```
for(int i=1;a+1>i;i++)System.out.println(Math.pow(i,a-i));
```
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 37 bytes
```
import StdEnv
$n=[i^(n-i)\\i<-[1..n]]
```
[Try it online!](https://tio.run/##S85JTcz7n5ufUpqTqpCbmJn3PzO3IL@oRCG4JMU1r4xLJc82OjNOI083UzMmJtNGN9pQTy8vNvZ/cEkiUJGtgoqC6f9/yWk5ienF/3U9ff67VOYl5mYmFwMA "Clean – 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]
# [R](https://www.r-project.org/), 34 bytes
```
x=1:scan();cat(x^rev(x-1),sep=',')
```
[Try it online!](https://tio.run/##K/r/v8LW0Ko4OTFPQ9M6ObFEoyKuKLVMo0LXUFOnOLXAVl1HXfO/6X8A "R – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
LD<Rm
```
Port of [*@lirtosiast*'s Jelly answer](https://codegolf.stackexchange.com/a/176669/52210).
[Try it online.](https://tio.run/##yy9OTMpM/f/fx8UmKPf/f1MA)
**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]
# [Lua](https://www.lua.org), 43 41 bytes
-2 bytes thanks to *@Shaggy*
```
s=io.read()for i=1,s do print(i^(s-i))end
```
[Try it online!](https://tio.run/##yylN/P@/2DYzX68oNTFFQzMtv0gh09ZQp1jbQCElX6GgKDOvRCMzTqNYN1NTMzUv5f9/UwA "Lua – Try It Online")
[Answer]
# 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]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
Ｉ⮌ＥＮＸ⁻θιι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEIyi1LLWoOFXDN7FAwzOvoLTErzQ3KbVIQ1NHISC/HMjwzcwrLdYo1FHI1ARhELD@/9/0v25ZDgA "Charcoal – 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]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 55 bytes
```
v=>Enumerable.Range(0,v--).Select(i=>Math.Pow(i+1,v--))
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpds45lXYmyko@Dpmleam1qUmJSTauOSXwqk7OwU0oAKFGwV/pfZ2iGk9YIS89JTNQx0ynR1NfWCU3NSk0s0Mm3tfBNLMvQC8ss1MrUNwXKa/625uMKLMktSfTLzUjUUgkuKMvPS9bzyM/M0FJR0QAhkgYaCqYImCFr/BwA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, 21 bytes
```
say++$\**--$_ while$_
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJbWyVGS0tXVyVeoTwjMydVJf7/f9N/@QUlmfl5xf91fU31DAwN/uvmAQA "Perl 5 – Try It Online")
]