Inferire sequenze geometriche


18

Haskell ha questa caratteristica ordinata (dall'aspetto) in cui puoi assegnargli tre numeri e può inferire una sequenza aritmetica da essi. Ad esempio, [1, 3..27]equivale a [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27].

È fantastico e tutte le sequenze aritmetiche tranne che abbastanza sono limitanti. Inoltre, pfft . La moltiplicazione è dove si trova. Non sarebbe più bello se facesse sequenze geometriche come [1, 3..27]tornare [1, 3, 9, 27]?

Sfida

Scrivere un programma / funzione che accetta tre numeri interi positivi a , b e c e genera dove x è il numero intero più grande ≤ c che può essere rappresentato come dove n è un numero intero positivo.[a, b, b × (b ÷ a), b × (b ÷ a)2, ..., x]b × (b ÷ a)n

Cioè, l'output dovrebbe essere r , in modo che:

r0 = a
r1 = b
rn = b × (b ÷ a)n-1
rlast = greatest integer ≤ c that can be represented as b × (b ÷ a)n
         where n is a positive integer

specificazioni

  • Si applicano le regole I / O standard .
  • Sono vietate le scappatoie standard .
  • b sarà sempre divisibile per a .
  • a < bc
  • Questa sfida non riguarda la ricerca dell'approccio più breve in tutte le lingue, ma piuttosto la ricerca dell'approccio più breve in ciascuna lingua .
  • Il tuo codice verrà assegnato un punteggio in byte , di solito nella codifica UTF-8, se non diversamente specificato.
  • Le funzioni integrate (Mathematica potrebbe avere una: P) che calcolano questa sequenza sono consentite ma è incoraggiata l'inclusione di una soluzione che non si basa su un built-in.
  • Le spiegazioni, anche per le lingue "pratiche", sono incoraggiate .

Casi test

a   b   c     r

1   2   11    [1, 2, 4, 8]
2   6   100   [2, 6, 18, 54]
3   12  57    [3, 12, 48]
4   20  253   [4, 20, 100]
5   25  625   [5, 25, 125, 625]
6   42  42    [6, 42]

In alcuni formati migliori:

1 2 11
2 6 100
3 12 57
4 20 253
5 25 625
6 42 42

1, 2, 11
2, 6, 100
3, 12, 57
4, 20, 253
5, 25, 625
6, 42, 42

@ Adám No. (vedi il primo caso di test)
user202729,

1
Nota che la formula è semplicemente b ^ n / a ^ n-1 . A partire da n = 0
H.Piz,

2
Ovviamente Mathematica ha un built-in ...
Neil,

è accettabile se i risultati non sono esattamente numeri interi dovuti a errori in virgola mobile?
Luis Mendo,

@LuisMendo Sì.
totalmente umano il

Risposte:


6

Buccia , 8 byte

~↑≤Ṡ¡o//

L'input è nell'ordine b, c, a . Provalo online!

Spiegazione

~↑≤Ṡ¡o//  Implicit inputs.
       /  a/b as exact rational number.
     o/   Divide by a/b (so multiply by b/a).
    ¡     Iterate that function
   Ṡ      on a. Result is the infinite list [a, b, b^2/a, b^3/a^2, ..
 ↑        Take elements from it while
~ ≤       they are at most c.

Il flusso di controllo in questo programma è un po 'difficile da seguire. Innanzitutto, b viene alimentato all'estrema destra /, producendo una funzione /bche divide per b . Avanti, ~divide il programma rimanente in tre parti: ~(↑)(≤)(Ṡ¡o//b). Ciò alimenta c a e a a Ṡ¡o//be combina i risultati con . Il risultato di ≤cè una funzione che controlla se il suo argomento è al massimo c e ↑≤cprende il prefisso più lungo degli elementi per cui è valido.

Resta da mostrare come (Ṡ¡o//b)avaluta l'elenco infinito desiderato. La parte tra parentesi è divisa in Ṡ(¡)(o//b). Quindi alimenta un a o//b, alimenta il risultato ¡e quindi dà un al suo secondo argomento. L'espressione (o//b)adà una funzione che accetta un numero e lo divide per a / b , e ¡itera questa funzione sul suo secondo argomento, che è a .

Ecco una serie di trasformazioni che visualizzano la spiegazione:

  (~↑≤Ṡ¡o//) b c a
= (~↑≤Ṡ¡o/(/b)) c a
= ~(↑)(≤)(Ṡ¡o/(/b)) c a
= ↑(≤c)((Ṡ¡o/(/b)) a)
= ↑(≤c)(Ṡ(¡)(o/(/b)) a)
= ↑(≤c)(¡(o/(/b)a) a)
= ↑(≤c)(¡(/(/ba))a)
Last line in English: takeWhile (atMost c) (iterate (divideBy (divideBy b a)) a)

Soluzione alternativa che utilizza variabili esplicite nell'ordine a, b, c :

↑≤⁰¡*/⁵²



3

JavaScript (ES6), 41 37 byte

Salvato 4 byte grazie a @Neil

Accetta input come (b,c)(a).

(b,c)=>g=a=>a>c?[]:[a,...g(b,b*=b/a)]

Casi test

Commentate

(b, c) =>                 // main function taking b and c
  g = a =>                // g = recursive function taking a
    a > c ?               //   if a is greater than c:
      []                  //     stop recursion and return an empty array
    :                     //   else:
      [ a,                //     return an array consisting of a, followed by 
        ...g(             //     the expanded result of a recursive call to g()
          b,              //       with a = b
          b *= b / a      //       and b = b * ratio
        ) ]               //     end of recursive call

1
Riordinare gli argomenti mi dà (b,c)=>g=a=>a>c?[]:[a,...g(b,b*=b/a)].
Neil,



2

Python 3, 93 90 74 73 byte

x=lambda a,b,c,i=0,q=[]:a*(b/a)**i>c and q or x(a,b,c,i+1,q+[a*(b/a)**i])

Provalo online

Grazie a Rod e user202729 per avermi aiutato a ridurre alcuni byte!


1
def + return -> lambda. Suggerimenti Python.
user202729,

1
Anche tu puoi import*.
user202729,

1
puoi usare while i<=c:i++(invece lista comprensione + log) per salvare molti byte
Rod

@Rod Come dovrei usare il ciclo while senza il registro? idk per quanto tempo iterare
Manish Kundu il


2

Ottava , 38 35 byte

@(a,b,c)exp(log(a):log(b/a):log(c))

Provalo online!

Risulta che l'approccio MATL di @ LuisMendo salva anche 3 byte in Octave, nonostante si ripeta logtre volte.


2

Perl 6 , 26 24 byte

{$^a,$^b,$b²/$a...^*>$^c}
{$^a,*×$^b/$a...^*>$^c}

Provalo online!

L'operatore di sequenza di Perl 6 ...può dedurre nativamente serie geometriche.

Aggiornamento: ... Può , ma in questa situazione non inferirlo è un po 'più breve.


1

05AB1E , 12 byte

Inserisci nell'ordine c,b,a

ÝmI¹Ý<m/ʒ¹›_

Provalo online!

Spiegazione

Ý              # push the range [0 ... c]
 m             # raise b to the power of each
  I            # push a
   ¹Ý          # push the range [0 ... c]
     <         # decrement each
      m        # push a to the power of each
       /       # elementwise division of ranges
        ʒ      # filter, keep only elements that are
         ¹›_   # not greater than c

1

MATL , 17 byte

t:,qtiw^w]x/tb>~)

Provalo online!

Solo per far rotolare la palla in MATL. Non riesco a immaginare che non ci sia un modo meno dettagliato per risolvere questo.


1
... Nessuna tripla negazione per favore.
user202729,

2
@ user202729 Non vedo come non avresti potuto capire che non era un incidente. :)
Sanchises,

Non intendi "Non vedo come non avresti potuto ottenere ciò che non era stato fatto involontariamente": P
HyperNeutrino,

@HyperNeutrino No.
Sanchises,



1

MATL , 12 byte

y/ivZlZ}3$:W

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

y     % Implicitly take two inputs, and duplicate the first onto the top
/     % Divide
i     % Take third input
v     % Vertically concatenate the three numbers into a column vector
Zl    % Binary logarithm, element-wise
Z}    % Split the vector into its three components
3$:   % Three-input range. Arguments are start, step, upper limit
W     % 2 raised to that, element-wise. Implicit display

1
Questo è davvero carino Stavo lottando con il riutilizzo ae c(ho molti tentativi falliti a partire da y/i), ma usando questo metodo, mantieni ordinatamente tutto insieme.
Sanchises,

1
questo approccio era in realtà 3 byte più breve anche in Octave.
Sanchises,

0

Perl, 38 byte

Includi +3per -n(il use 5.10.0per sbloccare le funzionalità perl 5.10 è gratuito)

#!/usr/bin/perl -n
use 5.10.0;
/ \d+/;say,$_*=$&/$`until($_+=0)>$'

Quindi esegui come:

geosequence.pl <<< "1 3 26"


0

Japt , 14 byte

ÆWpX zVpXÉÃf§U

Provalo


Spiegazione

                    :Implicit input of integers U=c, V=a & W=b
Æ         Ã         :Range [0,U) and pass each X through a function
 WpX                :  W to the power of X
     z              :  Floor divide by
      VpXÉ          :  V to the power of X-1
           f§U      :Filter elements less than or equal to U


0

TI-BASIC, 31 byte

Riceve input dall'utente e output Ans. Ho risolto per n in c = b n / a n-1 , ottenendo n = 1 + ln (c / b) / ln (b / a). È uguale a n = 1 + log b / a (c / b). Ai fini del golf, inizio la mia sequenza da -1 e finisco da n-1 anziché da 0 a n.

Prompt A,B,C
seq(B(B/A)^N,N,-1,logBASE(C/B,B/A

0

APL (Dyalog Unicode) , 38 byte

{(g≤⊃⌽⍵)⊆gf,(⍵[1]*p+1)÷(f←⊃⍵)*p←⍳⊃⌽⍵}

Provalo online!

Prefisso Dfn. Accetta l'input a b ce usa ⎕IO←0( I ndex O rigin )

Grazie a @ErikTheOutgolfer per aver rasato 6 byte da questo prima ancora che lo pubblicassi.

Come?

{(g≤⊃⌽⍵)⊆gf,(⍵[1]*p+1)÷(f←⊃⍵)*p←⍳⊃⌽⍵}  Prefix Dfn. Input  is a vector
                                    ⌽⍵   Reverse ⍵. Yields c b a
                                        Pick the first element (c)
                                        Index. Yields the integers 0..c-1
                                p       Assign to the variable p
                               *         Exponentiate
                         (f←⊃⍵)          Pick the first element of  (a) and assign to f
                                         This yields the vector (a^0, a^1, ..., a^c-1)
                        ÷                Element-wise division
                    p+1)                 The vector 1..c
                   *                     Exponentiate
              (⍵[1]                      Second element (because of IO0) of  (b)
                                         This yields the vector (b^1, b^2, ..., b^c)
            f,                           Prepend f (a). This yields the vector 
                                         (a, b^1/a^0, b^2/a^1, ...)
          g                             Assign the vector to g
                                        Partition. This takes a boolean vector as left
                                         argument and drops falsy elements of the right argument.
     ⊃⌽⍵)                                Pick the last element of  (c)
  (g                                    Check if each element of gc. Yields the boolean
                                         vector that is the left argument for 

0

Stax , 14 byte CP437

ü╞¥ß¥║/,5å╘⌂åº

16 byte quando decompresso,

E~Y/y{;^<}{[*gfm

Esegui ed esegui il debug online!

Accetta input sotto forma di [b, a, c].

Abbastanza sicuro che @recursive abbia soluzioni migliori.

Spiegazione

E~                              Parse  input, put `c` on input stack
  Y/                            Store `a` in register `y` and calculate `b`/`a`
    y                           Put `y` back to main stack, stack now (from top to bottom): [`a`, `b`/`a`]
     {   }{  gf                 generator
      ;^<                       Condition: if the generated number is smaller than the top of input stack (i.e. `c`)
           [*                   duplicate the second item in main stack and multiply it with the item at the top
                                   i.e. multiply last generated value by `b/a` and generate the value
              m                 Output array, one element on each line

0

SILOS , 73 byte

readIO
k=i
readIO
j=i
readIO
r=j/k
a=k
lbla
printInt a
a*r
b=i-a+1
if b a

Provalo online!

Leggiamo i tre numeri. Calcola il rapporto comune per il secondo numero / primo. Quindi corriamo attraverso la serie fino a quando non siamo più grandi del limite superiore.


0

C (gcc), 82 byte

n;f(a,b,c){float r=0;for(n=0;r<=c;)(r=pow(b,n)/pow(a,n++-1))<=c&&printf("%f ",r);}

Provalo online!

Calcola e stampa r_n = b^n/a^(n-1)fino al r_n > c.

Deve essere compilato con -lm!


69 byten;f(a,b,c){for(float r=n=0;r=pow(b/a,n++)*a,r<=c&&printf("%f ",r););}
ceilingcat

0

APL (Dyalog) , 23 byte ( SBCS )

Questo accetta argomenti ab a sinistra ec a destra,

{⊃(⍵∘≥⊆⊢)⊣/⍵2⍴⍺,÷\⍵⍴⌽⍺}

Provalo online!

C'è probabilmente un modo più breve, ma ci ho pensato ÷\ fosse carino.

Ha spiegato:

{...}La funzione anonoma ⍺ è a b, è c. Diciamoa b c = 2 6 100

⌽⍺Indietro :6 2

⍵⍴Ripetere i tempi:6 2 6 2 6 2 6 2 ...

÷\ Riduci per divisione sui prefissi: 6 (6÷2) (6÷(2÷6)) (6÷(2÷(6÷2))).. = 6 3 18 9 54 ..

⍺,Prepend :2 6 6 3 18 9 54 27 162 81 ...

⊣/⍵2⍴ Ottieni ogni altro elemento (più alcune ripetizioni finali):

  ⍵2⍴Crea una riga, 2matrice di colonne da2 6 6 3 18 9 54 ...

  ⊣/ Ottieni la prima colonna

⊆⊢ Dividi l'array in blocchi in cui

⍵∘≥ è maggiore o uguale a tutti gli elementi

Prendi il primo blocco del genere

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.