Wythoff superiore o inferiore?

20

Innanzitutto, parliamo delle sequenze di Beatty . Dato un numero irrazionale positivo r , possiamo costruire una sequenza infinita moltiplicando gli interi positivi per r in ordine e prendendo la base di ogni calcolo risultante. Per esempio,
Sequenza Beatty di r

Se r > 1, abbiamo una condizione speciale. Possiamo formare un altro numero irrazionale s come s = r / ( r - 1). Questo può quindi generare la propria sequenza Beatty, B s . Il trucco è che B r e B s sono complementari , il che significa che ogni numero intero positivo si trova esattamente in una delle due sequenze.

Se impostiamo r = ϕ, il rapporto aureo, otteniamo s = r + 1 e due sequenze speciali. La sequenza Wythoff inferiore per r :

1, 3, 4, 6, 8, 9, 11, 12, 14, 16, 17, 19, 21, 22, 24, 25, 27, 29, ...

e la sequenza Wythoff superiore per s :

2, 5, 7, 10, 13, 15, 18, 20, 23, 26, 28, 31, 34, 36, 39, 41, 44, 47, ...

Queste sono le sequenze A000201 e A001950 su OEIS, rispettivamente.

La sfida

Dato un numero intero di input positivo 1 <= n <= 1000, emettere uno di due valori distinti che indicano se l'input è nella sequenza Wythoff inferiore o nella sequenza superiore . I valori di output potrebbero essere -1e 1, truee false, uppere lower, ecc.

Sebbene l'algoritmo inviato debba teoricamente funzionare per tutti gli input, in pratica deve funzionare solo con i primi 1000 numeri di input.

I / O e regole

  • L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
  • Si può presumere che l'input e l'output si adattino al tipo di numero nativo della tua lingua.
  • È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
  • Sono vietate le scappatoie standard .
  • Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).
code-golf  number  sequence  decision-problem 
— AdmBorkBork
fonte
1
Fondamentalmente è "golf la sequenza Wythoff inferiore" perché la sequenza Wythoff superiore richiede 1 operazione in più rispetto a quella inferiore (phi quadrata).
— Magic Octopus Urn,

Risposte:

12

JavaScript (ES6), 50 35 byte

f=(n,s="1",t=0)=>s[n-1]||f(n,s+t,s)
<input type=number min=1 oninput=o.textContent=this.value&amp;&amp;f(this.value)><pre id=o>
Espandi frammento

Uscite 1per inferiore e 0per superiore. Spiegazione: Lista parziale dei valori booleani può essere costruito utilizzando un Fibonacci-like identità: dato due liste, a cominciare 1e 10, ciascuna lista successiva è la concatenazione dei due precedenti, con conseguente 101, 10110, 10110101ecc In questo caso è leggermente Golfier avere una finta 0esima voce 0e la usa per costruire il secondo elemento della lista.

— Neil
fonte
4
How the what ...
— AdmBorkBork,
4
Adoro come la spiegazione mi abbia fatto capire meno +1. I whoozits parziali booleani rubano l'identità di un uomo di nome Fibbonacci, che viene quindi collegato con i suoi nipoti per falsificare l'ingresso della costruzione.
— Magic Octopus Urn,
Ero curioso di sapere fino a che punto poteva funzionare questa versione a 33 byte usando un'approssimazione. La risposta è apparentemente fino a n = 375 .
— Arnauld,
7

Haskell , 26 byte

(l!!)
l=0:do x<-l;[1-x..1]

Provalo online!

Nessun galleggiante, precisione illimitata. Grazie per H.PWiz per due byte.

— XNOR
fonte
Anche questo sarebbe di 26 byte, ma non capisco perché non funziona
— H.Piz,
@ H.PWiz Penso che sia perché l'elenco vuoto è un punto fisso.
— xnor
Ah, non l'avevo considerato e lo stavo confrontando con un metodo "equivalente" usato ~(x:t). Grazie
— H.Pwiz,
@ H.PWiz / xnor Tecnicamente in Haskell il punto fisso utilizzato è il più piccolo denotazionalmente, qui in basso / undefined. Il fatto che ci siano anche due differenti definiti è solo accidentale.
— Ørjan Johansen,
7

Python , 25 byte

lambda n:-n*2%(5**.5+1)<2

Provalo online!

Utilizza la condizione molto semplice:

nè nella sequenza Wythoff inferiore esattamente se -n%phi<1.

Si noti che il risultato del modulo è positivo anche se -nè negativo, corrispondente a come Python fa il modulo.

Prova: Let a = -n%phi, che si trova nella gamma 0 <= a < phi. Possiamo dividere il -nmodulo phicome -n = -k*phi + aper un numero intero positivo k. Riorganizzare quello a n+a = k*phi.

Se a<1, quindi n = floor(n+a) = floor(k*phi), e così è nella sequenza Wythoff inferiore.

Altrimenti, abbiamo 1 <= a < phicosì

n+1 = floor(n+a) = floor(k*phi)
n > n+a-phi = k*phi - phi = (k-1)*phi

così ncade nel divario tra floor((k-1)*phi)e floor(k*phi) ed è perso dalla sequenza Wythoff inferiore.

Questo corrisponde a questo codice:

lambda n:-n%(5**.5/2+.5)<1

Provalo online!

Salviamo un byte raddoppiando a -(n*2)%(phi*2)<2.

— XNOR
fonte
Potresti spiegare come nasce la formula? Ho cercato di ricavarlo dalle definizioni della sequenza, ma mi sono perso nei boschi.
— Sundar - Ripristina Monica il
@sundar Aggiunta una prova.
— xnor
5

05AB1E , 9 byte

L5t>;*óså

Provalo online!

0 significa superiore, 1 significa inferiore. Prova i primi 100: provalo online!

    CODE   |      COMMAND      # Stack (Input = 4)
===========+===================#=======================
L          | [1..a]            # [1,2,3,4]
 5t>;      | (sqrt(5) + 1)/2   # [phi, [1,2,3,4]]
     *     | [1..a]*phi        # [[1.6,3.2,4.8,6.4]]
      ó    | floor([1..a]*phi) # [[1,3,4,6]]
       så  | n in list?        # [[1]]

Dump di comando non elaborato:

----------------------------------
Depth: 0
Stack: []
Current command: L

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4]]
Current command: 5

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], '5']
Current command: t

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 2.23606797749979]
Current command: >

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 3.23606797749979]
Current command: ;

----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 1.618033988749895]
Current command: *

----------------------------------
Depth: 0
Stack: [[1.618033988749895, 3.23606797749979, 4.854101966249685, 6.47213595499958]]
Current command: ó

----------------------------------
Depth: 0
Stack: [[1, 3, 4, 6]]
Current command: s

----------------------------------
Depth: 0
Stack: [[1, 3, 4, 6], '4']
Current command: å
1
stack > [1]
— Urna di polpo magico
fonte
Ho avuto lo stesso, ma usando ï:)
— Emigna il
@emigna Sono stato sorpreso che il phi non fosse nelle costanti matematiche. 5t>;a un byter 2 potrebbe non valerne la pena però ...
— Magic Octopus Urn,
Sì, stavo quasi ricordando che avrebbe potuto essere (ma non lo è). Sembra qualcosa che dovremmo aggiungere.
— Emigna,
@Emigna Sono abbastanza sicuro che la risposta di Jelly sia legittimamente questa, ma con un phi incorporato ahah.
— Magic Octopus Urn,
Haha ho avuto lo stesso, ma usando ïe ¢lol :) Tutte le nostre soluzioni sono così strettamente correlate
— Mr. Xcoder
5

Gelatina , 5 byte

N%ØpỊ

Provalo online!

Salvato 1 byte grazie al golf Python di xnor .

Gelatina , 6 byte

×€ØpḞċ

Provalo online!

Restituisce 1 per inferiore e 0 per superiore.

×€ØpḞċ – Full Program / Monadic Link. Argument: N.
×€     – Multiply each integer in (0, N] by...
  Øp   – Phi.
    Ḟ  – Floor each of them.
     ċ – And count the occurrences of N in that list.

(0,N]∩Zφ>1N>00<N<Nφ

— Mr. Xcoder
fonte
Immagino che una di queste sia una costante di 1 byte per phi: P?
— Magic Octopus Urn,
2
No, a due byte:Øp
— Mr. Xcoder
Hehe, meglio del mio 4 byte in 05AB1E:5t>;
— Magic Octopus Urn
4

Brain-Flak , 78 byte

([{}]()){<>{}((([()]))){{<>({}())}{}(([({})]({}{})))}<>([{}]{}<>)}<>({}()){{}}

Provalo online!

Non emette nulla per inferiore e 0per superiore. Passare a uno schema di output più sensato costerebbe 6 byte.

— Nitrodon
fonte
4

Python 2 , 39 33 32 byte

-6 byte grazie a Mr. Xcoder
-1 byte grazie a Zacharý

lambda n,r=.5+5**.5/2:-~n//r<n/r

Provalo online!

Restituisce Falseper inferiore e Trueper superiore

— asta
fonte
lambda n,r=(1+5**.5)/2:-~n//r<n/rsalva 6 byte.
— Mr. Xcoder,
1
Inoltre, lambda n,r=.5+5**.5/2:-~n//r<n/rdovrebbe funzionare anche per radere un byte
— Zacharý
3

Julia 0.6 , 16 byte

n->n÷φ<-~n÷φ

Provalo online!

Mentre giocavo con i numeri, mi sono imbattuto in questa proprietà: floor (n / φ) == floor ((n + 1) / φ) se n è nella sequenza Wythoff superiore e floor (n / φ) <floor ( (n + 1) / φ) se n è nella sequenza Wythoff inferiore. Non ho capito come nasce questa proprietà, ma dà i risultati corretti almeno fino a n = 100000 (e probabilmente oltre).

Vecchia risposta:

Julia 0.6 , 31 byte

n->n∈[floor(i*φ)for i∈1:n]

Provalo online!

Restituisce trueper la falsesequenza Wythoff inferiore e superiore.

— Sundar - Ripristina Monica
fonte
Poiché n / φ dei numeri fino a n sono inferiori e gli altri sono superiori, la differenza media tra i numeri inferiori successivi è φ; la divisione dei numeri inferiori per φ ti dà una sequenza in cui la differenza media è 1; questo rende possibile che il piano di quella sequenza sia il numero intero. La mia matematica non è abbastanza buona per andare oltre.
— Neil,
1

Wolfram Language (Mathematica) , 26 byte

#~Ceiling~GoldenRatio<#+1&

Provalo online!

Un intero nè nella iff Wythoff Sequence inferiore ceil(n/phi) - 1/phi < n/phi.

Prova che ceil(n/phi) - 1/phi < n/phiè ...

Sufficiente:

  1. Let ceil(n/phi) - 1/phi < n/phi.

  2. Poi, ceil(n/phi) * phi < n + 1.

  3. Nota n == n/phi * phi <= ceil(n/phi) * phi.

  4. Quindi, n <= ceil(n/phi) * phi < n + 1.

  5. Poiché ne ceil(n/phi)sono numeri interi, invochiamo la definizione di floor e state floor(ceil(n/phi) * phi) == ned nè nella sequenza Wythoff inferiore.

Necessario; prova del contrapositivo:

  1. Let ceil(n/phi) - 1/phi >= n/phi.

  2. Poi, ceil(n/phi) * phi >= n + 1.

  3. Nota n + phi > (n/phi + 1) * phi > ceil(n/phi) * phi

  4. Quindi n > (ceil(n/phi) - 1) * phi.

  5. Da allora (ceil(n/phi) - 1) * phi < n < n + 1 <= ceil(n/phi) * phi, nnon è nella sequenza Wythoff inferiore.

— JungHwan Min
fonte
Anche questo non ha alcun errore di arrotondamento.
— user202729,
1

Japt , 10 byte

Restituisce vero per inferiore e falso per superiore.

õ_*MQ fÃøU

Provalo online!

Spiegazione:

õ_*MQ fÃøU
             // Implicit U = Input
õ            // Range [1...U]
 _           // Loop through the range, at each element:
  *MQ        //   Multiply by the Golden ratio
      f      //   Floor
       Ã     // End Loop
        øU   // Return true if U is found in the collection
— Oliver
fonte
1
Ho avuto questo anche per 10 byte.
— Shaggy,
1

Java 10, 77 53 52 byte

n->{var r=Math.sqrt(5)/2+.5;return(int)(-~n/r)<n/r;}

Python 2 di Port of @ Rod .
-1 byte grazie a @ Zacharý .

Provalo online.

I vecchi 77 76 byte rispondono:

n->{for(int i=0;i++<n;)if(n==(int)((Math.sqrt(5)+1)/2*i))return 1;return 0;}

-1 byte grazie a @ovs 'per qualcosa che mi sono raccomandato la scorsa settimana .. xD

Restituisce 1per inferiore; 0per tomaia.

Provalo online.

Spiegazione:

n->{                    // Method with integer as both parameter and return-type
  for(int i=0;++i<=n;)  //  Loop `i` in the range [1, `n`]
    if(n==(int)((Math.sqrt(5)+1)/2*i))
                        //   If `n` is equal to `floor(Phi * i)`:
      return 1;         //    Return 1
  return 0;}            //  Return 0 if we haven't returned inside the loop already

i*Phiviene calcolato prendendo (sqrt(5)+1)/2 * i, e quindi lo pavimentiamo lanciandolo su un numero intero per troncare il decimale.

— Kevin Cruijssen
fonte
1
++i<=nsulla tua vecchia risposta può essere i++<n.
— Ovs,
1
— Kevin Cruijssen,
1
Penso che dovrebbe funzionare per -1 byte:n->{var r=Math.sqrt(5)/2+.5;return(int)(-~n/r)<n/r;}
— Zacharý
@ Zacharý Lo fa davvero, grazie!
— Kevin Cruijssen,
1

Haskell , 153 139 126 79 byte

Precisione illimitata!

l=length
f a c|n<-2*l a-c,n<0||l a<a!!n=c:a|1>0=a
g x=x==(foldl f[][1..x+1])!!0

Provalo online!

Spiegazione

Invece di utilizzare un'approssimazione del rapporto aureo per calcolare il risultato, il che significa che sono soggetti a errori man mano che la dimensione dell'input aumenta. Questa risposta no. Invece utilizza la formula fornita sull'OEIS che aè la sequenza univoca tale

∀n . b(n) = a(a(n))+1

dov'è bil complimento ordinato.

— Mago del grano
fonte
1
"Tutto" non era nemmeno vero prima che tu venissi sconfitto ...
— Neil,
@Neil buon punto. Devo aver perso la tua risposta.
— Wheat Wizard
Sebbene la tua risposta sia limitata dal fatto che javascript non ha un tipo integrale?
— Wheat Wizard
Bene, finirà la memoria molto prima di allora ...
— Neil,
1

Brachylog , 8 byte

≥ℕ;φ×⌋₁?

Provalo online!

Il predicato ha esito positivo se l'input si trova nella sequenza Wythoff inferiore e non riesce se si trova nella sequenza Wythoff superiore.

 ℕ          There exists a whole number
≥           less than or equal to
            the input such that
  ;φ×       multiplied by phi
     ⌋₁     and rounded down
       ?    it is the input.

Se la mancata chiusura è un metodo di output valido, è possibile omettere il primo byte.

— Stringa non correlata
fonte
Questa è probabilmente la prima volta che φviene utilizzata in un programma Brachylog. Finalmente!
— Fatalizza il
0

MATL , 8 byte

t:17L*km

Provalo online!

Spiegazione

t      % Implicit input. Duplicate
:      % Range
17L    % Push golden ratio (as a float)
*      % Multiply, element-wise
k      % Round down, element-wise
m      % Ismember. Implicit output
— Luis Mendo
fonte
0

K (oK) , 20 byte

Soluzione:

x in_(.5*1+%5)*1+!x:

Provalo online!

Spiegazione:

x in_(.5*1+%5)*1+!x: / the solution
                  x: / save input as x
                 !   / generate range 0..x
               1+    / add 1
              *      / multiply by
     (       )       / do this together
           %5        / square-root of 5
         1+          / add 1
      .5*            / multiply by .5
    _                / floor
x in                 / is input in this list?
— streetster
fonte
0

TI-BASIC (TI-84), 18 byte

max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans

L'ingresso è in Ans.
L'output è attivo Anse viene stampato automaticamente.
Stampa 1se l'input è nella sequenza inferiore o 0se è nella sequenza superiore.

0<N<1000

Esempio:

27
             27
prgmCDGFA
              1
44
             44
prgmCDGFA
              0

Spiegazione:

max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans    ;full program, example input: 5
                        randIntNoRep(1,Ans    ;generate a list of random integers in [1,Ans]
                                               ; {1, 3, 2, 5, 4}
              (√(5)+1)/2                      ;calculate phi and then multiply the resulting
                                              ;list by phi
                                               ; {1.618 4.8541 3.2361 8.0902 6.4721}
        iPart(                                ;truncate
                                               ; {1 4 3 8 6}
    Ans=                                      ;compare the input to each element in the list
                                              ;and generate a list based off of the results
                                               ; {0 0 0 0 0}
max(                                          ;get the maximum element in the list and
                                              ;implicitly print it

Nota: TI-BASIC è un linguaggio tokenizzato. Il conteggio dei caratteri non equivale al conteggio dei byte.

— Tau
fonte
0

cQuents , 5 byte

?F$`g

Provalo online!

Spiegazione

?         output true if in sequence, false if not in sequence
          each term in the sequence equals:

 F        floor (
  $               index * 
   `g                     golden ratio
     )                                 ) implicit
— Stefano
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.