Introduzione (potrebbe essere ignorata)

Mettere tutti i numeri positivi nel suo ordine regolare (1, 2, 3, ...) è un po 'noioso, no? Quindi ecco una serie di sfide intorno alle permutazioni (rimpasto) di tutti i numeri positivi. Questa è la quinta sfida di questa serie (collegamenti alla prima , seconda , terza e quarta sfida).

In questa sfida, incontreremo l'array Wythoff, che è una valanga intrecciata di sequenze di Fibonacci e sequenze di Beatty!

I numeri di Fibonacci sono probabilmente per molti di voi una sequenza ben nota. Dati due numeri iniziali $F_0$ e $F_1$ , i seguenti $F_n$ sono dati da: $F_n = F_{(n-1)} + F_{(n-2)}$ per $n>2$ .

La sequenza di Beatty , dato un parametro $r$ è: $B^r_n = \lfloor rn \rfloor$ per $n \ge 1$ . Una delle proprietà della sequenza di Beatty è che per ogni parametro $r$ , esiste esattamente un parametro $s=r/(r-1)$ , in modo tale che le sequenze di Beatty per quei parametri siano disgiunte e unite insieme, si estendono su tutti i numeri naturali escludendo 0 (ad es .: $B^r \cup B^{r/(r-1)} = \Bbb{N} \setminus \{0\}$).

Ora ecco che arriva la parte strabiliante: puoi creare un array, in cui ogni riga è una sequenza di Fibonacci e ogni colonna è una sequenza Beatty. Questo array è l' array Wythoff . La parte migliore è: ogni numero positivo appare esattamente una volta in questo array! L'array è simile al seguente:

   1    2    3    5    8   13   21   34   55   89  144 ...
   4    7   11   18   29   47   76  123  199  322  521 ...
   6   10   16   26   42   68  110  178  288  466  754 ...
   9   15   24   39   63  102  165  267  432  699 1131 ...
  12   20   32   52   84  136  220  356  576  932 1508 ...
  14   23   37   60   97  157  254  411  665 1076 1741 ...
  17   28   45   73  118  191  309  500  809 1309 2118 ...
  19   31   50   81  131  212  343  555  898 1453 2351 ...
  22   36   58   94  152  246  398  644 1042 1686 2728 ...
  25   41   66  107  173  280  453  733 1186 1919 3105 ...
  27   44   71  115  186  301  487  788 1275 2063 3338 ...
  ...

Un elemento alla riga $m$ colonna $n$ è definito come:

$A_{m,n} = \begin{cases} \left\lfloor \lfloor m\varphi \rfloor \varphi \right\rfloor & \text{ if } n=1\\ \left\lfloor \lfloor m\varphi \rfloor \varphi^2 \right\rfloor & \text{ if } n=2\\ A_{m,n-2}+A_{m,n-1} & \text{ if }n > 2 \end{cases}$

dove $\varphi$ è il rapporto aureo: $\varphi=\frac{1+\sqrt{5}}{2}$ .

Se seguiamo le anti-diagonali di questo array, otteniamo A035513 , che è la sequenza target per questa sfida (nota che questa sequenza viene aggiunta all'OEIS dallo stesso Neil Sloane !). Poiché si tratta di una sfida "sequenza pura", il compito è quello di produrre $a(n)$ per un dato $n$ come input, dove $a(n)$ è A035513 .

Ci sono diverse strategie che si possono seguire per arrivare a $a(n)$ , il che rende questa sfida (a mio parere) davvero interessante.

Compito

Dato un input intero $n$ , output $a(n)$ in formato intero, dove $a(n)$ è A035513 .

Nota: qui si assume l'indicizzazione basata su 1; puoi utilizzare l'indicizzazione basata su 0, quindi $a(0) = 1; a(1) = 2$ , ecc. Indicare questo nella risposta se si sceglie di utilizzarlo.

Casi test

Input | Output
---------------
1     |  1
5     |  7
20    |  20
50    |  136
78    |  30
123   |  3194
1234  |  8212236486
3000  |  814
9999  |  108240
29890 |  637

Potrebbe essere divertente sapere che il più grande $a(n)$ per $1\le n\le32767$ è $a(32642) = 512653048485188394162163283930413917147479973138989971 = F(256) \lfloor 2 \varphi\rfloor + F(255).$

Regole

• Input e output sono numeri interi
• Il tuo programma dovrebbe almeno supportare input nell'intervallo da 1 a 32767). Nota che $a(n)$ arriva fino a 30 cifre in questo intervallo ...
• Input non validi (0, float, stringhe, valori negativi, ecc.) Possono causare output non previsti, errori o comportamenti (non) definiti.
• Si applicano le regole I / O predefinite .
• Sono vietate le scappatoie predefinite .
• Questo è code-golf , quindi vince la risposta più breve in byte

Gelatina , 27 24 byte

p`SÞ⁸ịð’;×ØpḞ¥×⁹r‘ÆḞ¤Sð/

Provalo online!

Collegamento monadico utilizzando l'indicizzazione basata su 1. Grazie a @JonathanAllan per un modo migliore per ottenere la riga e le colonne ne salvare 3 byte. Nella sua forma più breve è troppo lento per N più grande su TIO, quindi quanto segue Provalo online! riduce la dimensione dell'elenco iniziale di righe e colonne al costo di tre byte.

Spiegazione

p`                       | Cartesian product of the range from 1..input with itself   
  SÞ                     | Sort by sum
    ⁸ị                   | Find the tuple at the position indicated by the input - this is the row and column
      ð               ð/ | Start a new dyadic chain using the row as the left and column as the right argument
       ’                 | Increase the row by 1
        ;    ¥           | Concatenate to:
         ×Øp             |   row × φ
            Ḟ            |   rounded down
              ×     ¤    | Multiply this pair by
                  ÆḞ     |   the Fibonacci numbers at positions
               ⁹         |   column index and
                r‘       |   column index plus one
                     S   | sum

Nota che si basa sulla descrizione del codice Python nella pagina OEIS.

R , 143 130 124 123 byte

function(n){k=0:n+1
`~`=rbind
m=k-1~(k*(1+5^.5)/2)%/%1
for(i in k)m=m~m[i,]+m[i+1,]
m=m[-1:-2,]
m[order(row(m)+col(m))][n]}

Provalo online!

Usa la formula $T(n,-1)=n-1; T(n,0)=\lfloor n\cdot\phi\rfloor;T(n,k)=T(n,k-1)+T(n,k-2)$per costruire l'array (trasposto), quindi splitsl'array lungo gli antidiagonali. kesiste semplicemente per impedire di forzare una drop=Fdiscussione nel m[-1:-2,]caso n=1.

Grazie a Neil per aver segnalato un golf da 1 byte.

R , 150 138 132 byte

function(n){T[2]=1
for(j in 2:n-1)T=c(T,T[j]+T[j+1])
m=T[-1]%o%((1:n*(.5+5^.5/2))%/%1)+T[-1-n]%o%(1:n-1)
m[order(row(m)+col(m))][n]}

Provalo online!

Implementa la formula $T(n,k)=Fib(k+1)\cdot\lfloor n\cdot\phi\rfloor+Fib(k)\cdot(n-1)$per generare l'array, quindi splitslungo gli antidiagonali ed estrae l' nthelemento.

Grazie a Robin Ryder per il T[2]=1trucco per generare la sequenza di Fibonacci.

Entrambe le soluzioni sono altamente inefficienti, creando una nxnmatrice di (molto probabilmente) doubles, poiché R promuove integer(con segno a 32 bit) doubleautomaticamente quando trabocca, ma la seconda dovrebbe essere molto più veloce. Prendere ncome un bignum dovrebbe funzionare automaticamente, usando la chiamata gmp::as.bigz(n), se la perdita di precisione sotto doubles fosse preoccupante, e quindi la lingua sarebbe R + gmp.

Wolfram Language (Mathematica) , 90 byte

Flatten[Table[(F=Fibonacci)[a+1]⌊(b-a+1)GoldenRatio⌋+(b-a)F@a,{b,#},{a,b,1,-1}]][[#]]&

Provalo online!

Gelatina , 30 byte

p`SÞ⁸ịð;Øp,²;\¤×Ḟ¥/;+ƝQƊ⁹¡ị@ð/

Provalo online!
Questo è un po 'lento, ma viene apportato un enorme miglioramento con un prefisso diḤ½Ċ(doppio, radice quadrata, soffitto) come in questa suite di test .

Carbone , 54 byte

Ｎθ≔⁰ηＷ‹ηθ«≦⊕η≧⁻ηθ»⊞υ¹Ｆθ⊞υ⁻⁺³ι§υ⊖§υι⊞υθＦ⁺²⁻θη⊞υΣ…⮌υ²Ｉ⊟υ

Provalo online!Il collegamento è alla versione dettagliata del codice. 0-indicizzati. Utilizza solo l'aritmetica intera, quindi funziona per valori arbitrari di grandi dimensioni. Spiegazione:

Ｎθ

Ingresso q .

≔⁰ηＷ‹ηθ«≦⊕η≧⁻ηθ»

Calcola l'antidiagonale sottraendo numeri sempre crescenti da q , che finisce con il numero di riga di destinazione m.

⊞υ¹Ｆθ⊞υ⁻⁺³ι§υ⊖§υι

Calcola i primi m+1termini di A019446 , anche se ci interessa solo il mth.

⊞υθＦ⁺²⁻θη⊞υΣ…⮌υ²

Calcola i primi n+4termini della serie generalizzata di Fibonacci che inizia con [a(m), m]. I termini di questa sequenza sono i mtermini di A019446 , A001477 , A000201 , A003622 , A035336 ; queste ultime due sono le prime due colonne dell'array Wythoff, e quindi questa sequenza continua con il resto della mquinta riga dell'array.

Ｉ⊟υ

Emette il termine desiderato.