16

Si consideri un triangolo in cui il N ° fila (1-indicizzato) è la matrice dei primi N potenze intere positive di N . Ecco le prime righe:

N | Triangolo

1 | 1
2 | 2 4
3 | 3 9 27
4 | 4 16 64 256
5 | 5 25 125 625 3125
...

Ora se concateniamo questi poteri in un'unica sequenza, otteniamo OEIS A075363 :

1, 2, 4, 3, 9, 27, 4, 16, 64, 256, 5, 25, 125, 625, 3125, 6, 36, 216, 1296, 7776, 46656 ...

Dato un intero N , il vostro compito è quello di restituire l' N esimo termine di questa sequenza. Puoi scegliere 0 o 1-indicizzazione.

Casi test

1-indicizzati:

N -> Uscita

1 -> 1
2 -> 2
3 -> 4
5 -> 9
10 -> 256
12 -> 25
15 -> 3125

0-indicizzati:

N -> Uscita

0 -> 1
1 -> 2
2 -> 4
4 -> 9
9 -> 256
11 -> 25
14 -> 3125

Si noti che queste scappatoie sono vietate per impostazione predefinita. Questo è code-golf , quindi vince l'invio valido più breve in ogni lingua!

— Mr. Xcoder
fonte

Penso che ci sia qualche errore nei casi di test: in 1 indicizzato 10 dovrebbero essere 256; in 0 con indice 9 dovrebbe essere 256.

— Galen Ivanov,

Possiamo avere spazi finali?

— Stan Strum,

@StanStrum Sì.

— Mr. Xcoder,

7

Python 3 , 39 byte

1-indicizzato

f=lambda x,n=1:n**x*(x<=n)or f(x-n,n+1)

Provalo online!

— Halvard Hummel
fonte

7

Buccia , 7 byte

!ṁṠM^ḣN

Provalo online!

1-indicizzato

Spiegazione:

      N   Get the list of all natural numbers
 ṁ        Map over each n in that list and then concatenate
  Ṡ  ḣ      Create the range [1,n] then ...
   M^       raise n to the power of each
!         Index into that sequence

— H.PWiz
fonte

5

Wolfram Language (Mathematica) , 32 byte

r=Range;Flatten[r@#^r@r@#][[#]]&

Provalo online!

Passa alla potenza delle gamme di gamme ...

— Martin Ender
fonte

Range@Range@3ritorna {{1}, {1, 2}, {1, 2, 3}}?! Accidenti, la lista delle discussioni di Mathematica è folle.

— numbermaniac

4

R , 40 byte

-2 byte che portano la risposta di Halvard Hummel

function(N){while(N>T){N=N-T;T=T+1};T^N}

Provalo online!

R , (risposta originale) 42 byte

function(N)(rep(1:N,1:N)^sequence(1:N))[N]

Provalo online!

1-indicizzati.

— Giuseppe
fonte

4

APL (Dyalog) , 15 13 10 byte

3 byte salvati grazie a @ Adám

⊢⊃∘∊⍳*⍳¨∘⍳

Provalo online!

Come?

⍳¨∘⍳ - creare un intervallo per ciascun numero nell'intervallo di input

⍳* - aumentare ogni numero nell'intervallo di input alle potenze corrispondenti

∊ - appiattire

⊢⊃ - scegli l'ennesimo elemento

— Uriel
fonte

Provandolo online il codice sembra essere di 17 byte e non sembra accettare un argomento intero scalare o produrre un singolo output intero

— Graham

1

@Graham Online, il codice viene assegnato a una variabile f(quindi f←sono 2 byte in più, che qui non vengono conteggiati) e c'è un cablaggio di prova che restituisce i risultati da 1a 10.

— Erik the Outgolfer,

Sicuramente è necessario contare tutti i byte inclusi tali incarichi e quelli necessari per accettare l'input in base alle specifiche della domanda e in uscita in base alle specifiche. La mia risposta APL richiede l'inserimento dello schermo.

— Graham,

@Graham questo è un dyal dllog APL. Non richiede l'assegnazione da applicare su nessun ingresso, l'uscita TIO è solo per una visione confortevole

— Uriel

Su tale base posso supporre di poter assegnare n all'interno del mio spazio di lavoro prima di eseguire un liner APL e quindi di salvare 7 byte, non sono sicuro che i nostri colleghi concorrenti lo accetteranno.

— Graham,

3

Gelatina , 7 byte

*R$€Ẏ⁸ị

Provalo online!

-1 grazie a Mr. Xcoder .

1-indicizzati.

— Erik the Outgolfer
fonte

Codice fantastico proprio qui.

— Jonathan Allan,

Sbarazzandomi della sintassi elaborata ", la mia soluzione è di 7 byte:*R$€F⁸ị

— Mr. Xcoder,

@ Mr.Xcoder Grazie, anche se avevo già rimosso il ", ma comunque. Ecco cosa ottieni studiando la storia: /

— Erik the Outgolfer,

3

Haskell , 30 28 byte

Salvato 2 byte grazie a xnor.

([n^m|n<-[1..],m<-[1..n]]!!)

Provalo online!

0-indicizzato

— H.PWiz
fonte

1

In realtà è più breve utilizzare l'elenco comp [n^i|n<-[1..],i<-[1..n]].

— xnor

Oh, lo stavo confrontando con il >>=modulo ...

— H.Pwiz,

3

MATL , 9 byte

:t!^RXzG)

L'indicizzazione è basata su 1. Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considera l'input 5come esempio.

:     % Implcit input n. Push range [1 2 ... n]
      % STACK: [1 2 3 4 5]
t!^   % Matrix of all pair-wise powers
      % STACK: [1    2    3    4    5;
                1    4    9   16   25;
                1    8   27   64  125;
                1   16   81  256  625;
                1   32  243 1024 3125]
R     % Upper triangular matrix
      % STACK: [1    2    3    4    5;
                0    4    9   16   25;
                0    0   27   64  125;
                0    0    0  256  625;
                0    0    0    0 3125]
Xz    % Nonzeros. Reads values in column-major order
      % STACK: [1; 2; 4; 3; 9; ...; 625; 3125]
G)    % Get n-th entry (1-based). Implcit display
      % STACK: 9

— Luis Mendo
fonte

3

APL (Dyalog) , 14 12 byte

{⍵⌷∊*∘⍳⍨¨⍳⍵}

Provalo online!

Utilizza 1-indicizzazione

Salvato 2 byte con ↑,/ → ∊, tratto dalla risposta di Graham

Si noti che nel collegamento di prova, il codice richiede un extra f←, ma questo non viene conteggiato secondo le nostre regole.

— H.PWiz
fonte

Uso molto intelligente di ∘con ⍨.

— Adám,

@Adám Thanks :-)

— H.PWiz,

{⍵⌷∊*∘⍳⍨¨⍳⍵}→ ⊢⌷∘∊((*∘⍳)⍨¨⍳)→ ⊢⌷∘∊(⍳(*∘⍳)¨⍳)→⊢⌷∘∊⍳*∘⍳¨⍳

— Adám

— Pubblicherei

⊢è una funzione tacita ciò che ⍵è un dfn. Il ∘mezzo ⌷e ∊è necessario perché ∊viene chiamato monadicamente, quindi viene indicizzato l' elenco . E cambiamo f⍨⍳in ⍳ f ⍳per evitare di chiamare f ( *∘⍳¨) monadicamente (ogni volta ⍨che ¨sono adiacenti, possono scambiare posizione).

— Adám,

3

Pyth , 8 byte

@s^RSdSh

Provalo qui.

-1 grazie a Steven H ..

0-indicizzati.

— Erik the Outgolfer
fonte

@s^RSdShgolf un byte off.

— Steven H.

2

05AB1E , 9 byte

ƒNDLm`}I@

Provalo online!

Spiegazione

1-indicizzati.

ƒ           # for N in range [0 ... input]
 N          # push N
  DL        # push range [1 ... N]
    m       # raise N to the power of each in [1 ... N]
     `      # flatten to stack
      }     # end loop
       I@   # get the element at index (input)

Soluzione alternativa su un elenco anziché su un ciclo

ÝεDLm}˜sè

— Emigna
fonte

1

Perl 6 , 29 byte

{({|($++X**1..$++)}...*)[$_]}

Provalo

Allargato:

{  # bare block lambda with implicit parameter ｢$_｣

  (  # generate the sequence

    {  # code block used to generate each value in the sequence

      |(         # slip the values into the outer sequence

        $++      # post-incremented anonymous state value
        X**      # cross using &infix:«**»
        1 .. $++ # from 1 to post-incremented anonymous state value

      )
    }

    ...          # keep generating values until

    *            # never stop

  )[ $_ ]        # index into the sequence (0-based)
}

— Brad Gilbert b2gills
fonte

1

Rubino , 34 byte

->n{w=0;n-=w+=1until n<0;w**=w-~n}

Provalo online!

— GB
fonte

1

JavaScript , 30 byte

-1 byte grazie a Nahuel Fouilleul

f=(x,n=1)=>x>n?f(x-n,n+1):n**x

Provalo online!

— FlipTack
fonte

-1 byte invertendo il testf=(x,n=1)=>x>n?f(x-n,n+1):n**x

— Nahuel Fouilleul

@NahuelFouilleul ovviamente, grazie!

— FlipTack

0

Python 2 , 57 byte

lambda N:[n**-~e for n in range(N+2)for e in range(n)][N]

Provalo online! (0-indicizzati.)

Versione lunga indicizzata 0 byte 74 byte .

— Jonathan Frech
fonte

0

Gelatina , 15 12 byte

_{Probabilmente non ottimale.}

-3 grazie al golf di Erik the Outgolfer .

=RṁR€T€µT*FḢ

Provalo online!

— Jonathan Allan
fonte

Wow, oggi devi essere davvero stanco.

— Erik the Outgolfer,

In realtà sono davvero malato!

— Jonathan Allan,

10

Scusate! Spero ti rimetta presto!

— Erik the Outgolfer,

Inoltre, ecco circa 3 byte di distanza che sono riuscito a ricavare da questo banalmente.

— Erik the Outgolfer,

0

J , 20 byte

{1,[:;[:(^&.><\)1+i.

1-indicizzato

Provalo online!

— Galen Ivanov
fonte

0

APL + WIN, 23 byte

(∊n↑¨⊂[2]n∘.*n←⍳n)[n←⎕]

Spiegazione:

[n←⎕] prompts for screen input and selects the nth element of the concatenated vector
see below

n←⍳n creates a vector of 1 to n

∘.* outer product with exponentiation as the operator

⊂[2] enclose each row of the resulting array as an element of a nested array

∊n↑¨ take 1 to n elements from the 1 to nth row of the matrix and concatenate into a vector

— Graham
fonte

Su quale dialetto APL funziona?

— Erik the Outgolfer,

È scritto in APL + WIN. Lo chiarirò in tutte le risposte future

— Graham,

Ho preso ∊dalla tua risposta per sostituire il mio ↑,/. Non conoscevo quella funzione. Grazie

— H.Piz,

@EriktheOutgolfer Penso che funzionerà su qualsiasi APL moderno.

— Adám,

0

SILOS , 45 byte

readIO
lblb
a+1
i-a
if i b
i+a
a^i
printInt a

Provalo online!

— Perdente Suora
fonte

0

Perl 5, 30 + 1 (-p) byte

$_-=$.++until$.>$_;$_=$.**++$_

provalo online

— Nahuel Fouilleul
fonte

0

Clojure 51 byte

0 indicizzato, ad esempio i 9ritorni di input 256.0.

#(nth(for[i(range)j(range i)](Math/pow i(inc j)))%)

— NikoNyrh
fonte

0

C 76, 62 byte

y;f(n){for(y=0;n>y*++y/2;);return(int)pow(y-1,n+y*(3-y)/2-1);}

~~y; f (n) {y = (int) - +2 (5 + sqrt (1 + 8 * ~ -n) / 2.); n + = y * (3-y) / 2-1; ritorno (int ) pow (y-1, n);}~~

L'ho basato su questo codice

Provalo su ideone

— PrincePolka
fonte

0

Pyt , 39 37 byte

1-indicizzato

←000`ŕŕ⁺ĐĐř^Đ04Ș↔+⇹Ł-Đ↔3Ș0>łŕ0↔⇹+⁻⦋↔ŕ

Spiegazione:

In breve, calcola ogni riga. Se il numero richiesto è in quella riga, restituirlo; altrimenti, vai alla riga successiva.

— mudkip201
fonte

La sequenza di numeri interi esponenziali

Casi test

Python 3 , 39 byte

Buccia , 7 byte

Spiegazione:

Wolfram Language (Mathematica) , 32 byte

R , 40 byte

R , (risposta originale) 42 byte

APL (Dyalog) , 15 13 10 byte

Gelatina , 7 byte

Haskell , 30 28 byte

MATL , 9 byte

Spiegazione

APL (Dyalog) , 14 12 byte

Pyth , 8 byte

05AB1E , 9 byte

Perl 6 , 29 byte

Allargato:

Rubino , 34 byte

JavaScript , 30 byte

Python 2 , 57 byte

Gelatina , 15 12 byte

J , 20 byte

APL + WIN, 23 byte

SILOS , 45 byte

Perl 5, 30 + 1 (-p) byte

Clojure 51 byte

C 76, 62 byte

Pyt , 39 37 byte