Este es mi primer desafío en este sitio.

El desafío es tomar un número entero de entrada $n$ , que será positivo, e imprimir, en orden ascendente ( $1$ a $n$ , incluido n ), la salida de $i^{(n-i)}$ (donde $i$ es el número entero actual).

Ejemplo

Dada la entrada 5, el programa imprimirá:

1  
8  
9  
4  
1  

$1^4$ es 1 y$1+4=5$
$2^3$ es 8 y$2+3=5$
$3^2$ es 9 y$3+2=5$
$4^1$ es 4 y$4+1=5$
$5^0$ es 1 y$5+0=5$

Entrada y salida

La entrada tendrá la forma de un entero positivo. La salida será una lista de números, delimitada por comas o nuevas líneas.

Este es el código de golf , por lo que gana el código más corto.

APL (Dyalog Unicode) , 8 5 bytes

⍳*⊢-⍳

Pruébalo en línea!

Prefijo anónimo función tácita. TIO prueba para el rango [1..10].

Gracias @lirtosiast por 3 bytes.

Cómo:

⍳*⊢-⍳ ⍝ 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),...]

Haskell, 23 bytes

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

Pruébalo en línea!

Versión alternativa, también 23 bytes:

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

Japt, 5 bytes

õ_p´U

Intentalo

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

Perl 6 , 19 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma un número y devuelve una lista. Zip exponentes el rango 1 to inputy el rangoinput-1 to 0

Aheui (esótopo) , 193 164 bytes (56 caracteres)

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

Pruébalo en línea!

Pruébalo en AVIS ( coreano ); simplemente copie y pegue el código anterior, presione el botón de inicio, ingrese un número, vea cómo se mueve. Para ver la salida, presione > _ icono en el lado izquierdo.

No se juega mucho al golf, pero lo intento.

Pyth , 5 bytes

_m^-Q

Pruébalo en línea!

Esta codificación óptima sería de 4.106 bytes.

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

J , 10 bytes

(>:^|.)@i.

Pruébalo en línea!

Si realmente necesitamos separar los números por una nueva línea:

J , 13 bytes

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

Pruébalo en línea!

Jalea , 5 bytes

R*ḶU$

Pruébalo en línea!

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

PHP, 32 bytes

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

Ejecutar como tubería -nRo probarlo en línea .

Octava , 18 bytes

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

Pruébalo en línea!

Gracias Luis Mendo , el uso de variables internas ahorra 3 bytes.

Jalea , 4 bytes

*ạ¥€

Pruébalo en línea!

Wolfram Language (Mathematica) , 24 20 18 bytes

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

Pruébalo en línea!

-4 gracias @lirtosiast.

MathGolf , 6 bytes

rx\╒m#

Pruébalo en línea!

Python 2 , 40 bytes

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

Pruébalo en línea!

Python 2 , 41 bytes

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

Pruébalo en línea!

Rubí , 27 bytes

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

Pruébalo en línea!

Retina , 35 bytes

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

Pruébalo en línea! Explicación:

.+
*

Convierta la entrada a unario.

_

Empareja cada posición. Esto establece varias variables de reemplazo. $`se convierte en la izquierda del partido; $>`modifica esto para que sea la izquierda y el partido; $.>`modifica esto para tomar la longitud, es decir, el índice actual. $'mientras tanto es el derecho del partido, también lo $.'es la longitud, es decir, el exponente actual.

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

Crea una cadena $.(más $.'repeticiones de $.>`*más _. Por ejemplo, para un índice de 2 en una entrada original de 5, $.'es 3 y $.>`es 2, entonces la cadena resultante es $.(2*2*2*_. Esto es convenientemente una expresión de reemplazo de retina que calcina 2³. Cada cadena se emite en su propia línea.

%~`^
.+¶

Para cada línea generada por la etapa anterior, prefije una línea .+, convirtiéndola en una etapa de reemplazo y evalúe esa etapa, calculando así la expresión.

QBasic, 35 33 bytes

¡Gracias @Neil por 2 bytes!

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

Versión ligeramente ampliada en REPL.IT porque el intérprete no está completamente a la altura.

Salida

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

   5
1
8
9
4
1

F # (.NET Core) , 42 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 33 32 bytes

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

Pruébalo en línea!

-3 bytes con créditos a @Shaggy, y -1 byte por @ l4m2!

JavaScript (Node.js) , 36 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 37 bytes

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 46 bytes

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

Pruébalo en línea!

MATL , 5 bytes

:Gy-^

Pruébalo en línea!

Explicación

Considere la entrada 5como un ejemplo.

:     % 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]

Java, 59 bytes

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

Limpio , 37 bytes

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

Pruébalo en línea!

Define $ :: Int -> [Int]tomar un número entero y devolver la lista de resultados.

$ 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
   ]

R , 34 bytes

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

Pruébalo en línea!

05AB1E , 5 bytes

LD<Rm

Respuesta de Port of @lirtosiast 's Jelly .

Pruébalo en línea.

Explicación:

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]

Lua , 43 41 bytes

-2 bytes gracias a @Shaggy

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

Pruébalo en línea!

R, 22 bytes

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

Bastante autoexplicativo; tenga en cuenta que el :operador tiene mayor precedencia que el -operador, por lo que n:1-1es más corto que(n-1):0

Si se nos permite comenzar en 0, entonces podemos perder dos bytes al (0:n)^(n:0)evitar la necesidad de un -1.

Carbón de leña , 9 bytes

Ｉ⮌ＥＮＸ⁻θιι

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

   Ｎ        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

C # (compilador interactivo de Visual C #) , 55 bytes

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

Pruébalo en línea!

Perl 5 -n , 21 bytes

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

Pruébalo en línea!