Eppure coppie inutilizzate

21

Definiamo una sequenza di numeri interi positivi. Definiremo la sequenza su numeri pari per raddoppiare il termine precedente. Gli indici dispari della sequenza saranno i numeri interi positivi più piccoli non ancora presenti nella sequenza.

Ecco i primi termini della coppia.

1,2,3,6,4,8,5,10,7,14,9,18,11,22,12,24,13,26,15,30

Puoi anche pensare a questo come all'elenco delle coppie concatenate (n, 2n) dove n è finora l'intero positivo meno inutilizzato.

Compito

Dato un numero n come input calcolare il n esimo termine in questa sequenza.

Questo è code-golf quindi dovresti mirare a ridurre al minimo le dimensioni del tuo codice sorgente misurato in byte.

OEIS A036552

code-golf  sequence 
— Mago del grano
fonte
Il fatto che gli indici dispari della sequenza saranno i numeri interi positivi più piccoli non ancora presenti nella sequenza. è irrilevante, vero?
— Adám,
1
Inoltre, quali coppie ?
— Adám,
@ Adám No, non è così. Non sono sicuro di cosa ti dia quell'impressione, forse l'ho espresso male.
— Wheat Wizard
1
@Adám un altro modo di pensare alla sequenza è che è costituito da coppie concatenate (n,2n)e ogni numero appare solo una volta. Ogni coppia viene scelta per essere la più piccola possibile mentre aderisce a quest'ultimo vincolo.
— Martin Ender,
3
La valutazione 2-adic di elementi dispari della serie è sempre pari. Potrebbe essere utile a qualcuno.
— CalcolatriceFeline

Risposte:

11

Haskell, 40 byte

l(a:r)=a:2*a:l[x|x<-r,x/=2*a]
(l[1..]!!)

Zero-based. lcostruisce in modo incrementale la sequenza da un elenco pigro di numeri interi rimanenti.

— Christian Sievers
fonte
7

JavaScript (ES6), 92 82 69 67 65 byte

n=>(F=i=>i^n?F(a[b=i&1?2*b:(g=k=>a[k]?g(k+1):k)(1)]=-~i):b)(a={})

Come?

Teniamo traccia di:

  • L'ultimo valore inserito b .
  • Tutti i valori precedentemente rilevati nella tabella di ricerca a .

Internamente, stiamo utilizzando un indice basato su 0 i . Pertanto, si invertono comportamenti dispari e pari:

  • A posizioni dispari, il valore successivo è semplicemente 2 * b.

  • In posizioni pari, utilizziamo la funzione ricorsiva g () e la tabella di ricerca a per identificare il valore di corrispondenza più piccolo:

    (g = k => a[k] ? g(k + 1) : k)(1)

Per salvare qualche byte, i viene inizializzato a {}piuttosto che 0. Questo ci obbliga a usare:

  • i^nper confrontare i con n perché ({}) ^ n === nconsiderando che ({}) - nvaluta NaN.
  • -~i incrementare i , perché({}) + 1genererebbe una stringa.

dimostrazione

Mostra snippet di codice

— Arnauld
fonte
— Shaggy
5

Python 3 , 80 72 69 byte

-7 byte grazie a Mr. Xcoder !

f=lambda n:n and[f(n-1)*2,min({*range(n+1)}-{*map(f,range(n))})][n%2]

Provalo online!

— notjagan
fonte
1
Puoi ripetere set(...)con `{* ...} per 78 byte
— Mr. Xcoder il
@ Zacharý Ti riferivi al mio commento? In tal caso, un set in Python 3 può essere {*...}invece di set(...).
— Mr. Xcoder,
Stavo commentando senza pensare, mi sono reso conto pochi istanti dopo che {...for...in...}sarebbe stato più ciao.
— Zacharý,
In realtà, risparmierebbe 4 byte, perché lo usi due volte
— Mr. Xcoder,
— Wheat Wizard
3

PHP, 56 byte

while($$n=$i++<$argn)for($n*=2;$i&$$k&&$n=++$k;);echo$n;

PHP, 75 72 byte

for($a=range(1,$argn);$i++<$argn;)$a[~-$n=$i&1?min($a):2*$n]=INF;echo$n;

Provalo online

— Titus
fonte
3

05AB1E , 16 15 14 byte

1-indicizzati.
Utilizza il fatto che la rappresentazione binaria di elementi con indici dispari nella sequenza termina con un numero pari di zero: A003159 .

Lʒb1¡`gÈ}€x¹<è

Provalo online!

Spiegazione

L                 # range [1 ... input]
 ʒ      }         # filter, keep only elements whose
  b               # ... binary representation
   1¡             # ... split at 1's
     `gÈ          # ... ends in an even length run
         €x       # push a doubled copy of each element in place
           ¹<è    # get the element at index (input-1)
— Emigna
fonte
3

Python 2 , 59 51 49 byte

f=lambda n,k=2:2/n%-3*(1-k)or f(n+~(k&-k)%-3,k+1)

Provalo online!

sfondo

Ogni numero intero positivo n può essere espresso in modo univoco come n = 2 o (n) c (n) , dove c (n) è dispari.

Lasciate ⟨a n ⟩ n> 0 la successione dal spec sfida.

Sosteniamo che, per tutti gli interi positivi n , o (a 2n-1 ) è pari. Poiché o (a 2n ) = o (2a 2n-1 ) = o (a 2n-1 ) + 1 , ciò equivale a rivendicare che o (a 2n ) è sempre dispari.

Supponiamo che l'affermazione sia falsa e che 2m-1 sia il primo indice dispari della sequenza in modo tale che o (un 2m-1 ) sia dispari. Si noti che ciò rende 2m il primo indice pari della sequenza in modo tale che o (un 2m-1 ) sia pari.

o (un 2m-1 ) è dispari e 0 è pari, quindi un 2m-1 è divisibile per 2 . Per definizione, un 2m-1 è il numero intero positivo più piccolo che non appare ancora nella sequenza , il che significa che un 2m-1 /2 deve essere apparso prima. Sia k il (primo) indice di un 2m-1 /2 in a .

Poiché o (a k ) = o (a 2m-1 /2) = o (a 2m-1 ) - 1 è pari, la minimalità di n implica che k è dispari. A sua volta, ciò significa che una k + 1 = 2a k = a 2m-1 , in contraddizione con la definizione di un 2m-1 .

Come funziona

ancora da venire

— Dennis
fonte
3

R , 70 69 65 byte

function(n){for(i in 2*1:n)F[i-1:0]=which(!1:n%in%F)[1]*1:2
F[n]}

Provalo online!

Una funzione anonima che accetta un argomento. Fil valore predefinito èFALSE o0 in modo tale che l'algoritmo valuta, giustamente, che non sono numeri interi positivi nella sequenza ancora.

L'algoritmo genera le coppie in un forciclo nel seguente modo (dove ipassa da 2a 2nda 2):

           which(!1:n%in%l)[1]     # the missing value
                              *1:2 # keep one copy the same and double the next
l[i-1:0]=                         # store into l at the indices i-1 and i
— Giuseppe
fonte
2

Perl 6 , 50 byte

{(1,{@_%2??2*@_[*-1]!!first *∉@_,1..*}...*)[$_]}

Provalo online!

  • 1, { ... } ... *è una sequenza infinita generata pigramente in cui ogni termine dopo il primo è fornito dal blocco di codice delimitato da parentesi graffe. Poiché il blocco fa riferimento a@_ all'array, riceve l'intera sequenza corrente in quell'array.
  • Se il numero attuale di elementi è dispari ( @_ % 2), stiamo generando un elemento a indicizzazione pari, quindi l'elemento successivo è il doppio dell'ultimo elemento che abbiamo finora:2 * @_[*-1] .
  • In caso contrario, si ottiene il primo numero intero positivo che ancora non compare nella sequenza: first * ∉ @_, 1..*.
  • $_è l'argomento della funzione esterna. Si indicizza nella sequenza infinita, fornendo il valore di ritorno della funzione.
— Sean
fonte
1

Mathematica, 82 byte

(s={};a=1;f=#;While[f>0,If[s~FreeQ~a,s~AppendTo~{a,2a}];a++;f--];Flatten[s][[#]])&

Provalo online!

— J42161217
fonte
58 byte in Mathematica (anche se probabilmente dovrei semplicemente pubblicare una risposta separata poiché l'idea è piuttosto diversa).
— notjagan,
L'hai copiato dal link OEIS?
— J42161217,
L'ho modificato per adattarlo al compito e per giocare di più, ma è più o meno lo stesso del link OEIS.
— notjagan,
1
@Non pubblicare una nuova risposta se si desidera e accreditare l'autore
— J42161217
1

k , 27 byte

*|{x,*(&^x?!y;|2*x)2!y}/!2+

1-indicizzati. Provalo online!

Utilizzando al (!y)^xposto di &^x?!yfunziona anche.

— zgrep
fonte
1

C # (compilatore interattivo Visual C #) , 82 byte

x=>{int y=1;for(var s="";x>2;x-=2)for(s+=2*y+":";s.Contains(++y+""););return x*y;}

Provalo online!

-6 byte grazie a @ASCIIOnly!

— dana
fonte
C # 8 potrebbe essere troppo nuovo per essere comune negli interpreti online per ora, aggiunto al fatto che csi è una cosa Mono, quindi dovresti aspettare che Mono lo implementi e lo aggiunga a una build stabile (se non ha t già)
— ASCII il
purtroppo non è facile da controllare per questo in C #
— ASCII-solo
Usalo per iniziare? Ma sì, non sembra una cosa semplice. docs.microsoft.com/en-us/dotnet/api/…
— dana
1
86? - Non pensare che le :s siano necessarie poiché sarà il numero più grande nella lista
— ASCII il
Anche 2.0=>2f
— dana il
0

Clojure, 102 byte

#(nth(loop[l[0 1 2 3]i %](if(= i 0)l(recur(conj l(*(last l)2)(nth(remove(set l)(range))0))(dec i))))%)

Scorre i ntempi per costruire la sequenza e restituisce l' nelemento th, 1-indicizzato.

— NikoNyrh
fonte
0

Rubino, 60 byte

->n,*a{eval"v+=1while a[v];a[v]=a[2*v]=v+v*n%=2;"*(n/2+v=1)}

0-indicizzati. Effettuiamo il loop dei n/2+1tempi, generando due valori ogni volta e memorizzandoli popolando un array nei loro indici. v+v*n%2fornisce l'uscita, sia vo v*2seconda della parità n.

— histocrat
fonte
0

Rubino , 49 byte

->n{*s=t=0;s|[t+=1]==s||s<<t<<t*2until s[n];s[n]}

Inizia con [0], aggiungi coppie all'array fino a quando non abbiamo almeno n + 1 elementi, quindi prendi n + 1 ° (basato su 1)

Provalo online!

— GB
fonte
0

JavaScript (ES6), 60 65 byte

Una soluzione iterativa.

n=>eval("for(s={},i=0;n;)s[++i]?0:(s[i+i]=--n)?--n?0:i+i:i")

Meno golf

n=>{
  s = {}; //hashtable for used values
  for(i=0; n; )
  {
    if ( ! s[++i] )
    {
      s[i*2] = 1; // remember i*2 is already used
      if (--n)
        if (--n)
          0;
        else
          result = i*2;
      else
        result = i;
    }
  }
  return result;  
}

Test

F=
n=>eval("for(s={},i=0;n;)s[++i]?0:(s[i+i]=--n)?--n?0:i+i:i")

for (a=1; a < 50; a++)
  console.log(a,F(a))
Espandi frammento

— edc65
fonte
0

Gelatina , 13 12 10 byte

ḤRọ2ḂĠZFị@

Questo utilizza l'osservazione dalla mia risposta Python .

Provalo online!

Come funziona

ḤRọ2ḂĠZFị@  Main link. Argument: n

Ḥ           Unhalve; yield 2n.
 R          Range; yield [1, ... , 2n].
  ọ2        Compute the order of 2 in the factorization of each k in [1, ..., 2n].
    Ḃ       Bit; compute the parity of each order.
     G      Group the indices [1, ..., 2n] by the corresponding values.
      Z     Zip/transpose the resulting 2D array, interleaving the indices of 0
            with the indices of 1, as a list of pairs.
       F    Flatten. This yields a prefix of the sequence.
        ị@  Take the item at index n.
— Dennis
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.