Sfida

Scrivi una funzione / programma che emetta il n'th elemento, o i primi nelementi, nella sequenza numerica ben nota:

         1, 2, 4, 8, 16 ...

Oh, aspetta ... Ho dimenticato i primi numeri:

1, 1, 1, 1, 2, 4, 8, 16 ...

Cavolo, ne aggiungerò altri per una buona misura:

1, 1, 1, 1, 2, 4, 8, 16, 33, 69, 146, 312, 673, 1463, 3202, 7050, 15605, 34705 ...

I numeri sono numeri catalani generalizzati forniti dalla formula (indicizzata zero):

un' (n + 1) = un' (n) + Σ_{K = 2}^{n - 1} un' (K) \cdot un' (n - 1 - K)

$a(n+1)= a(n) + \sum_{k=2}^{n-1} a(k)\cdot a(n-1-k)$

dove

un' (0) = un' (1) = un' (2) = un' (3) = 1

$a(0)= a(1)= a(2)= a(3) = 1$

Questo è OEIS A004149 .

È possibile scegliere se si desidera avere la sequenza zero o uno indicizzata. Naturalmente la sequenza deve essere la stessa, quindi è necessario riscrivere la formula se la si è indicizzata.

— Stewie Griffin
fonte

Correggetemi se sbaglio qui, ma la modifica di una formula one-indicizzato è di cambiare a(n-1-k)a a(n-k), giusto?

— Sumner18

9

Questo mi ricorda La legge forte dei piccoli numeri

— Luis Mendo,

23

Python , 51 byte

f=lambda n,k=2:n<3or k<n and f(k)*f(n-k-2)+f(n,k+1)

Provalo online!

Semplifica un po 'la formula:

un' (n) = Σ_{K = 2}^{n - 1} un' (K) \cdot un' (n - 2 - K)

$a(n) = \sum_{k=2}^{n-1} a(k)\cdot a(n-2-k)$

un' (- 1) = un' (0) = un' (1) = un' (2) = 1

$a(-1) = a(0)= a(1)= a(2) = 1$

— XNOR
fonte

8

Congratulazioni per il 100k !!

— Stewie Griffin,

Da quando sono arrivato anche a questa soluzione in modo indipendente, devo dire che il percorso verso di essa è un po 'accidentato ...

— Erik the Outgolfer

10

Perl 6 , 44 byte

{1,1,1,1,{sum @_[2..*]Z*@_[@_-4...0,0]}...*}

Provalo online!

Blocco di codice anonimo che restituisce una sequenza infinita di valori pigri. Questo praticamente implementa la sequenza come descritto, con la scorciatoia che zip moltiplica tutti gli elementi finora dopo il secondo elemento con il retro dell'elenco a partire dal quarto elemento e aggiungendo un extra 1alla fine.

Spiegazione:

{                                          }  # Anonymous code block
                                       ...*   # Create an infinite sequence
 1,1,1,1,                                     # Starting with four 1s
         {                            }       # Where each new element is:
          sum                                   # The sum of
              @_[2..*]                          # The second element onwards
                      Z*                        # Zip multiplied with
                        @_[@_-4...0  ]          # The fourth last element backwards
                                   ,0           # And 1

— Jo King
fonte

10

05AB1E , 14 13 11 byte

$ƒˆ¯Âø¨¨¨PO

Provalo online!

Emette l'ennesimo elemento, indicizzato 0.

$                # push 1 and the input
 ƒ               # repeat (input+1) times
  ˆ              #  add the top of the stack (initially 1) to the global array
   ¯             #  push the global array
    Â            #  and a reversed copy of it
     ø           #  zip the two together, giving a list of pairs
      ¨¨¨        #  drop the last 3 pairs
         P       #  take the product of each pair (or 1 if the list is empty)
          O      #  take the sum of those products
                 #  after the last iteration, this is implicitly output;
                 #  otherwise, it's added to the global array by the next iteration

— Grimmy
fonte

7

JavaScript (ES6), 42 byte

Una porta della soluzione di xnor .

0-indicizzati.

f=(n,k=2)=>n<3||k<n&&f(k)*f(n+~++k)+f(n,k)

Provalo online!

JavaScript (ES6), 83 75 byte

Una soluzione più veloce, meno ricorsiva, ma significativamente più lunga.

0-indicizzati.

f=(n,i,a=[p=1])=>a[n]||f(n,-~i,[...a,p+=(h=k=>k<i&&a[k]*a[i-++k]+h(k))(2)])

Provalo online!

— Arnauld
fonte

7

Haskell, 49 43 39 byte

a n=max(sum[a k*a(n-2-k)|k<-[2..n-1]])1

Provalo online!

Per n<3il sumè 0, quindi max ... 1solleva a 1.

Modifica: -6 byte grazie a @Jo King.

— Nome del modello
fonte

6

Wolfram Language (Mathematica) , 36 byte

Sum[#0@i#0[#-i-1],{i,3,#-1}]/. 0->1&

Provalo online!

1-indicizzati.

La sequenza 2-indicizzato è 4 byte corta: Sum[#0@i#0[#-i],{i,#-4}]/. 0->1&. Provalo online!

— attinat
fonte

2

Impressionante che questo sia più corto di quello incorporato CatalanNumber!

— erfink,

6

05AB1E , 17 13 byte

4Å1λ£₁λ¨Â¦¦s¦¦*O+

Non più breve della risposta 05AB1E esistente , ma volevo provare la funzionalità ricorsiva della nuova versione 05AB1E come pratica per me stesso. ~~Potrebbe forse essere golfato da pochi byte.~~ EDIT: E in effetti può, vedere la versione ricorsiva di @Grimy 05AB1E risposta s' al di sotto, che è di 13 byte .

$n$

$n$ £è
£

Spiegazione:

$a(n)= a(n-1) + \sum_{k=2}^{n-1}(a(k)\cdot a(n-1-k))$

$a(0)=a(1)=a(2)=a(3)=1$

   λ               # Create a recursive environment,
    £              # to output the first (implicit) input amount of results after we're done
4Å1                # Start this recursive list with [1,1,1,1], thus a(0)=a(1)=a(2)=a(3)=1
                   # Within the recursive environment, do the following:
      λ            #  Push the list of values in the range [a(0),a(n)]
       ¨           #  Remove the last one to make the range [a(0),a(n-1)]
        Â          #  Bifurcate this list (short for Duplicate & Reverse copy)
         ¦¦        #  Remove the first two items of the reversed list,
                   #  so we'll have a list with the values in the range [a(n-3),a(0)]
           s       #  Swap to get the [a(0),a(n-1)] list again
            ¦¦     #  Remove the first two items of this list as well,
                   #  so we'll have a list with the values in the range [a(2),a(n-1)]
              *    #  Multiply the values at the same indices in both lists,
                   #  so we'll have a list with the values [a(n-3)*a(2),...,a(0)*a(n-1)]
               O   #  Take the sum of this list
     ₁          +  #  And add it to the a(n-1)'th value
                   # (afterwards the resulting list is output implicitly)

Versione di 13 byte di @Grimy (assicurati di votare la sua risposta se non l'hai ancora fatto!):

1λ£λ1šÂ¨¨¨øPO

$n$

1λèλ1šÂ¨¨¨øPO
λλ1šÂ¨¨¨øPO $a(0)=1$

Spiegazione:

$a(n) = \sum_{k=2}^{n-1}(a(k)\cdot a(n-2-k))$

$a(-1) = a(0) = a(1) = a(2) = 1$

 λ             # Create a recursive environment,
  £            # to output the first (implicit) input amount of results after we're done
1              # Start this recursive list with 1, thus a(0)=1
               # Within the recursive environment, do the following:
   λ           #  Push the list of values in the range [a(0),a(n)]
    1š         #  Prepend 1 in front of this list
      Â        #  Bifurcate the list (short for Duplicate & Reverse copy)
       ¨¨¨     #  Remove (up to) the last three value in this reversed list
          ø    #  Create pairs with the list we bifurcated earlier
               #  (which will automatically remove any trailing items of the longer list)
           P   #  Get the product of each pair (which will result in 1 for an empty list)
            O  #  And sum the entire list
               # (afterwards the resulting list is output implicitly)

— Kevin Cruijssen
fonte

1

Interessante che questo possa risolvere un (1200) in 40 secondi su tio, mentre altri approcci ricorsivi scadono per numeri n di 100 ...

— Stewie Griffin

1

Ho anche realizzato (ma non pubblicato) una versione ricorsiva. Sono 13 byte per i primi n termini o 11 byte per un elenco infinito . Il caso speciale a (n-1) costa molti byte e non è necessario (vedere ad esempio la formula di xnor ).

— Grimmy,

@Grimy Ti dispiace se aggiungo le tue soluzioni ricorsive alla mia risposta (accreditandoti ovviamente)? Lascerò anche la mia risposta originale. Ma è bello vedere le differenze tra la formula originale e la formula per il risparmio di byte di xnor. :)

— Kevin Cruijssen il

1

Certo, va bene!

— Grimmy,

@StewieGriffin Sì, sono stato anche colpito dalla velocità di queste infinite funzioni ricorsive. Forse uno dei punti di forza di Elixir, e sicuramente dovuto al caricamento lento incorporato. Calcola n=100in 0,65 secondi , ma quando disabilito il caricamento lento, scade invece dopo 60 secondi, anche pern=25 .

— Kevin Cruijssen,

5

Python 3 , 59 byte

davvero inefficiente, a(13)non finisce su TIO.

a=lambda n,k=2:n<4or(n-k<2)*a(n-1)or a(k)*a(n-k-2)+a(n,k+1)

Provalo online!

— OVS
fonte

3

Gelatina , 17 byte

1WṪ;+¥×Uṫ3SƲ;@Ʋ⁸¡

Provalo online!

$n$ $0$ $n$

— Nick Kennedy
fonte

2

Haskell , 76 byte

1:1:1:f[1,1,1]
f(x:z)|y<-x+sum(zipWith(*)(init$init z)$reverse z)=y:f(y:x:z)

Provalo online!

— flawr
fonte

2

APL (Dyalog Extended) , ^{SBCS da} 34 byte

-2 grazie a dzaima.

Prefisso anonimo lambda.

{⍵≤3:1⋄+/(∇⍵-1),⍵(-×⍥∇¯2+⊢)¨4…⍵}

Provalo online!

— Adamo
fonte

@dzaima Grazie. TFW qualcuno conosce la mia lingua meglio di me :-)

— Adám

2

Japt , 19 17 16 byte

Emette il ntermine th, 1 indicizzato.

@Zí*Zz2)Å¤x}g4Æ1

Provalo

@Zí*Zz2)Å¤x}g4Æ1     :Implicit input of integer U
@                    :Function taking an array as an argument via parameter Z
 Zí                  :  Interleave Z with
    Zz2              :  Z rotated clockwise by 180 degrees (simply reversing would be a bye shorter but would modify the original array)
   *                 :  Reduce each pair by multiplcation
       )             :  End interleave
        Å            :  Slice off the first element
         ¤           :  Slice off the first 2 elements
          x          :  Reduce by addition
           }         :End function
            g        :Pass the following as Z, push the result back to it and repeat until it has length U
             4Æ1     :Map the range [0,4) to 1s
                     :Implicit output of the last element

— ispido
fonte

1

Haskell , 65 byte

f a|a<4=1|z<-g[2..a]=sum$zipWith(*)z$reverse(1:g[0..a-4])
g=map f

Provalo online!

È possibile utilizzare fper ottenere un singolo elemento di una sequenza o passare un elenco di valori a ge ottenere tutti gli indici per tale elenco.

— Jo King
fonte

1

Forth (gforth) , 99 81 byte

: f recursive dup 4 > if 0 over 3 do over 1- i - f i f * + loop else 1 then nip ;

Provalo online!

L'output è l'ennesimo termine e l'input è 1 indicizzato

Modifica: salvato 17 byte passando alla formula di xnor. Salvato un altro 1 byte usando 1-indicizzato

Spiegazione del codice

: f                     \ start a new word definition
  recursive             \ mark that this word will be recursive
  dup 4 >               \ duplicate the input and check if it is greater than 4
  if                    \ if it is:
    0 over              \ create an accumulator and copy n to top of stack
    3 do                \ start counted loop from 3 to n-1
      over 1- i - f     \ recursively calculate f(n-1-i)
      i f               \ recursively calculate f(i)
      * +               \ multiply results and add to accumulator
    loop                \ end the counted loop        
  else                  \ otherwise, if n < 5
    1                   \ put 1 on the stack
  then                  \ end the if block
  nip                   \ drop n from the stack
;                       \ end the word definition

— reffu
fonte

1

Carbone , 26 byte

Ｆ⁵⊞υ¹ＦＮ⊞υΣ✂Ｅ⮌υ×κ§υλ³→Ｉ§υ±⁴

Provalo online! Il collegamento è alla versione dettagliata del codice. Stampa l'ennesimo numero con indice 0, sebbene calcoli utilizzando internamente l'indicizzazione 1. Spiegazione:

Ｆ⁵⊞υ¹

Inizia con a[0] = a[1] = a[2] = a[3] = a[4] = 1. Sì, questo è 1-indicizzato, ma con un valore zeroth aggiuntivo. Questo è il codice golf per te.

ＦＮ

Calcola ntermini aggiuntivi . Questo è eccessivo, ma rende più facile trovare il termine desiderato quando n<5.

⊞υΣ✂Ｅ⮌υ×κ§υλ³

Per ogni termine, calcola il termine successivo come somma dei termini fino a quel momento moltiplicata per il termine moltiplicata per il contrario dei termini finora, escludendo tre termini.

→

Questo è un no-op usato per ingannare il carbone nell'analisi della forma a 2 argomenti Slice, altrimenti dovrei usare un modo meno golfy di rimuovere tre termini.

Ｉ§υ±⁴

Emette il 4o ultimo termine.

— Neil
fonte

1

Pyth , 30 byte

J*4]1VQ=+J+eJsPP*M.t,PJ_PJ0;<J

Provalo online!

Restituisce il primo $n$ elementi della sequenza.

J*4]1VQ=+J+eJsPP*M.t,PJ_PJ0;<JQ # Full program, last Q = input (implicitly added)
J*4]1                  # J = 4 * [1] (=[1,1,1,1])
VQ                     # for N in range(Q):
  =+J                  #  J +=
     +eJ               #   J[-1] + 
        s              #    sum(                           )
           *M          #     map(__operator_mul,          )
             .t      0 #      transpose(          , pad=0)
               ,       #       [       ,         ]
                PJ     #         J[:-1] 
                  _PJ  #                 J[1::-1]
<JQ                    # J[::Q]

Alternativa: sostituire <con @per restituire il $n$ -th elemento della sequenza, indicizzato 0.

— ar4093
fonte

1

Rubino , 42 41 byte

f=->n{n<4?1:(4..n).sum{|i|f[i-1]*f[n-i]}}

Provalo online!

1 indicizzato (per salvare 1 byte)

— GB
fonte

1

Ottava , 73 byte

g=(1:4).^0;for(i=3:(n=input('')))g(i+2)=g(4:i+1)*g(i-(2:i-1))';end;g(end)

Provalo online!

-2 byte grazie a Stewie Griffin. Ancora una volta, l'approccio imperativo vince sull'approccio funzionale ricorsivo. Quello è mostrato sotto.

Ottava , 75 byte

f(f=@(a)@(n){@()sum(arrayfun(@(k)a(a)(k)*a(a)(n-2-k),2:n-1)),1}{2-(n>3)}())

Provalo online!

Captcha voleva verificare che fossi un essere umano quando pubblicavo questo. Ad essere sincero, non ne sono così sicuro .

— Sanchises
fonte

Non riesco a vedere alcun modo ovvio per accorciare l'approccio ad anello ... Sembra abbastanza ben giocato! Inoltre, non capita spesso di vedere l'indicizzazione a base zero in Octave :)

— Stewie Griffin,

@StewieGriffin Dal momento che la ricorsione ha alcune compensazioni che non si davvero importa se si sceglie zero o uno indicizzazione. Penso che forse potrei radere alcuni byte se avessi fatto l'indicizzazione 2, ma mi è sembrato un imbroglio. Ad ogni modo, la tua intuizione era giusta - in qualche modo, questo era davvero più breve in modo anonimo ricorsivo. Penso che il vantaggio principale sia che gestisce molto bene la creazione dei quattro valori iniziali perché restituisce solo 1 per n<4.

— Sanchises,

1

@StewieGriffin Certo, buona vecchia moltiplicazione di matrici. Molto bene!

— Sanchises,

0

Perl 5 `-MList::Util=sum` , 61 byte

sub a{my$b=-2+pop;$b<2||sum a($b+1),map{a($_)*a($b-$_)}2..$b}

Provalo online!

— Xcali
fonte

0

C / C ++ , 70 69 67 byte

-1 byte grazie a Jonathan.

int a(int n){int k=2,s=0;while(++k<n)s+=a(k)*a(n+~k);return s?s:1;}

Provalo online!

— polfosol ఠ_ఠ
fonte

Può a(n-1-k)essere a(n+~k)?

— Jonathan Frech,

a(++k)*a(n-k)È probabile che @JonathanFrech funzioni anche e cade di altri 2 byte da for. Ma sento odore di comportamento indefinito.

— polfosol ఠ_ఠ

Questo sembra essere un problema di sequenziamento; sicuramente UB.

— Jonathan Frech,

1, 2, 4, 8, 16, ... 33?

Sfida

Python , 51 byte

Perl 6 , 44 byte

Spiegazione:

05AB1E , 14 13 11 byte

JavaScript (ES6), 42 byte

JavaScript (ES6), 83 75 byte

Haskell, 49 43 39 byte

Wolfram Language (Mathematica) , 36 byte

05AB1E , 17 13 byte

Python 3 , 59 byte

Gelatina , 17 byte

Haskell , 76 byte

APL (Dyalog Extended) , SBCS da 34 byte

Japt , 19 17 16 byte

Haskell , 65 byte

Forth (gforth) , 99 81 byte

Spiegazione del codice

Carbone , 26 byte

Pyth , 30 byte

Rubino , 42 41 byte

Ottava , 73 byte

Ottava , 75 byte

Perl 5 -MList::Util=sum , 61 byte

C / C ++ , 70 69 67 byte

APL (Dyalog Extended) , ^{SBCS da} 34 byte

Perl 5 `-MList::Util=sum` , 61 byte