21

Storia

Quindi ho un libro che voglio separare dal mio tavolo con nient'altro che altri libri. Voglio sapere di quanti libri ho bisogno per raggiungere questo obiettivo con lunghezze di libro. $n$

Ecco una visualizzazione che il mio amico di Wolfram ha disegnato per me:

una visualizzazione da Wolfram

Ulteriori informazioni sull'argomento in Wolfram e Wikipedia .

Sfida

Dato un input intero , genera quanti libri sono necessari affinché il libro in cima sia lunghezza del libro lontano dalla tabella in orizzontale. oppure Trova il valore intero più piccolo di per l'ingresso nella seguente disuguaglianza. $n$ $n$

$m$ $n$

Σ_{io = 1}^{m} \frac{1}{2 io} \geq n

$\sum_{i=1}^{m}\frac{1}{2i} \geq n$

Modifica: per le frazioni utilizzare almeno un punto mobile IEEE a precisione singola. _{scusate la sfida di modifica dopo la pubblicazione}

_{( OEIS A014537 )}

Casi test

 1          4
 2         31
 3        227
 5      12367
10  272400600

— betseg
fonte

1

youtube.com/watch?v=pBYPXsGka74 <- related

— streetster

Deve usare questa particolare disposizione dei libri, quale IIRC non è ottimale?

— user253751

13

Ottava , 41 40 33 byte

1 byte salvato grazie a @Dennis

@(n)find(cumsum(.5./(1:9^n))>n,1)

Provalo online!

Spiegazione

Questo utilizza il fatto che i numeri armonici possono essere limitati da una funzione logaritmica.

Inoltre, il >=confronto può essere sostituito dal >fatto che i numeri armonici non possono essere nemmeno numeri interi (grazie, @Dennis!).

@(n)                                   % Anonymous function of n
                     1:9^n             % Range [1 2 ... 9^n]
                .5./(     )            % Divide .5 by each entry
         cumsum(           )           % Cumulative sum
                            >n         % Is each entry greater than n?
    find(                     ,1)      % Index of first true entry

— Luis Mendo
fonte

11

Python 3 , 35 byte

f=lambda n,k=2:n>0and-~f(n-1/k,k+2)

Provalo online!

— Dennis
fonte

10

Buccia , 8 byte

V≥⁰∫m\İ0

Provalo online!

Dato che Husk usa numeri razionali quando può, questo non ha problemi in virgola mobile

Spiegazione

      İ0    The infinite list of positive even numbers
    m\      Reciprocate each
   ∫        Get the cumulative sum
V           Find the index of the first element
 ≥⁰         that is greater than or equal to the input

— H.PWiz
fonte

8 byte, ma in quale set di caratteri?

— john16384,

3

@ john16384 Husk ha una sua codepage in cui ogni simbolo corrisponde a un singolo byte. Ecco il hexdump corrispondente

— H.Piz,

5

JavaScript, 30 byte

Una funzione ricorsiva, quindi si esaurirà abbastanza presto.

f=(n,x=0)=>n>0?f(n-.5/++x,x):x

Provalo online

— ispido
fonte

4

Haskell, 38 byte

k!n|n<=0=0|x<-n-1/(2*k)=1+(k+1)!x
(1!)

— Capinera
fonte

3

Rapido , 65 byte

func f(n:Double){var i=0.0,s=i;while s<n{i+=1;s+=0.5/i};print(i)}

Provalo online!

Ungolfed

func f(n:Double) {
  var i = 0.0, s = 0.0
  while s < n {
    i += 1;
    s += 0.5 / i
  }
  print(i)
}

— Herman L
fonte

3

R , 39 byte

function(n){while((F=F+.5/T)<n)T=T+1;T}

Provalo online!

Forza bruta!

— Giuseppe
fonte

3

Javascript (ES6), 34 byte

n=>eval("for(i=0;n>0;n-=.5/i)++i")

Ungolfed

n => {
    for(i = 0; n > 0; ++i)
        n -= .5 / i
    return i;
}

Casi test

Mostra snippet di codice

f=n=>eval("for(i=0;n>0;n-=.5/i)++i")

<button onclick="console.log(f(1))">Run for n = 1</button>
<button onclick="console.log(f(2))">Run for n = 2</button>
<button onclick="console.log(f(3))">Run for n = 3</button>
<button onclick="console.log(f(5))">Run for n = 5</button>
<button onclick="console.log(f(10))">Run for n = 10</button>

Espandi frammento

— Herman L
fonte

È venuto con una soluzione simile usando la ricorsione per 30 byte. Non so se pubblicarlo o no, dopo aver visto il tuo.

— Shaggy,

1

Forse mi manca qualcosa, ma perché è necessario racchiuderlo in una evaldichiarazione?

— caird coinheringaahing il

1

@cairdcoinherigaahing, senza evalla idovrebbe essere variabile returncato alla fine, a costo di qualche ulteriore byte.

— Shaggy,

2

Gelatina , 8 byte

RİSH:ð1#

Questo è molto lento.

Provalo online!

— Dennis
fonte

2

Haskell, 71 49 48 byte

f x=length.fst.span(<x).scanl(+)0$(0.5/)<$>[1..]

@BMO mi ha salvato un enorme 22 byte!

— Capinera
fonte

2

Julia 0.6 , 30 27 byte

<(n,i=1)=n>0?n-.5/i<i+1:i-1

Provalo online!

Funziona solo fino a n = 6, perché Julia non ha ottimizzazione delle chiamate di coda.

-3 byte grazie a Dennis .

— Lukes
fonte

2

TI-BASIC, 27 byte

Richiede l'input dell'utente e visualizza l'output al termine. Nota: ⁻¹è il token ^-1 (inverso).

Input N
1
Repeat 2N≤Σ(I⁻¹,I,1,Ans
Ans+1
End
Ans

— kamoroso94
fonte

2

Se avete intenzione di salvare Ansin Nimmediatamente, allora Input No Prompt Nè un metodo di input che consente di risparmiare un byte sopra Ans→N. E Mpuò essere sostituito da Ans, in modo che 1→Mdiventi 1e M+1→Mdiventi Ans+1. (Ma sono scettico su un output Ansche non viene visualizzato - vedi questo - quindi forse finire con :Ansè appropriato: quindi il valore verrà mostrato al posto di "Fatto".)

— Misha Lavrov

Grazie! Sapevo che mi Ans→Nsentivo divertente. Ottime ottimizzazioni. Ho anche preso il tuo consiglio sull'output solo per sicurezza. Esce ancora con un netto -3 byte: D

— kamoroso94

1

05AB1E , 11 byte

XµN·zODI›}N

Provalo online!

Spiegazione

Xµ       }    # loop until counter is 1
  N·z         # push 1/(2*N)
     O        # sum the stack
      DI›     # break if the sum is greater than the input
          N   # push N

— Emigna
fonte

1

Pyth , 10 byte

f!>Qsmc1yh

Provalo online!

Estremamente lento.

Pyth , 10 byte

fgscL1STyQ

Provalo online!

— Mr. Xcoder
fonte

1

Japt , 12 byte

Stessa lunghezza, ma leggermente più efficiente dell'opzione ricorsiva.

@T¨(Uµ½÷X}a1

Provalo

Spiegazione

@T¨(Uµ½÷X}a1
                 :Implicit input of integer U
@        }a1     :Return the first number X >=1 that returns truthy when passed through the following function
 T               :Zero
  ¨              :Greater than or equal to
    Uµ           :Decrement U by...
      ½÷X        :0.5 divided by X

— ispido
fonte

1

J, 22 byte

-6 byte grazie a frownyfrog

I.~0+/\@,1%2*1+[:i.9&^

Provalo online!

risposta originale

La risposta di Luis in J:

1+]i.~[:<.[:+/\1%2*1+[:i.9&^

Ungolfed

1 + ] i.~ [: <. [: +/\ 1 % 2 * 1 + [: i. 9&^

Principalmente curioso di vedere se può essere drasticamente migliorato ( miglia di paging della tosse )

Spiegazione

1 +      NB. 1 plus... 
] i.~    NB. find the index of the arg in...
[: <.    NB. the floor of...
[: +/\   NB. the sumscan of...
1 %      NB. the reciprical of...
2 *      NB. two times...
1 +      NB. 1 plus...
[: i.    NB.  the integers up to 
9&^      NB. 9 raised to the power of the arg

Provalo online!

— Giona
fonte

1+]i.~[:<.-> 1+]I.~->I.~0,

— FrownyFrog

ofc! grazie frownyfrog

— Giona

E poiI.~0+/\@,

— FrownyFrog il

Se modifichi,

— batterai

@FrownyFrog, fatto. se hai un po 'di tempo, mi piacerebbe vederti risolvere questo: codegolf.stackexchange.com/questions/154345/bracket-expansion . tutte le soluzioni a cui riesco a pensare sono troppo dettagliate per pubblicare in buona coscienza ...

— Giona

0

PHP, 35 byte

while($argv[1]>$s+=.5/++$i);echo$i;

Eseguilo utilizzando l'interfaccia della riga di comando:

$ php -d error_reporting=0 -r 'while($argv[1]>$s+=.5/++$i);echo$i;' 5

— axiac
fonte

0

Wolfram Language (Mathematica) , 40 byte

⌈x/.NSolve[HarmonicNumber@x==2#,x]⌉&

Provalo online!

— alephalpha
fonte

0

Java 8, 49 byte

n->{float r=0,s=0;for(;s<n;)s+=.5f/++r;return r;}

Spiegazione:

Provalo online. (Timeout per i casi di test sopra n=7.)

n->{             // Method with integer parameter and float return-type
  float r=0,     //  Result-float, starting at 0
        s=0;     //  Sum-float, starting at 0
  for(;s<n;)     //  Loop as long as the sum is smaller than the input
    s+=.5f/++r;  //   Increase the sum by `0.5/(r+1)`,
                 //   by first increasing `r` by 1 with `r++`
  return r;}     //  Return the result-float

— Kevin Cruijssen
fonte

0

tinylisp , 98 byte

(load library
(d _(q((k # N D)(i(l N(* D # 2))(_(inc k)#(+(* N k)D)(* D k))(dec k
(q((#)(_ 1 # 0 1

L'ultima riga è una funzione lambda senza nome che prende il numero di lunghezze dei libri e restituisce il numero di libri necessari. Provalo online!

Spiegazione

L'unico tipo di dati numerico che tinylisp ha sono numeri interi, quindi calcoliamo le serie armoniche come una frazione tenendo traccia del numeratore e del denominatore. Ad ogni passo, Nè il numeratore, Dè il denominatore ed kè l'indice di somma. Vogliamo che la nuova somma parziale sia N/D + 1/k, o (N*k + D)/(D*k). Pertanto, si ricorre a un nuovo numeratore di N*K + D, un nuovo denominatore di D*ke un nuovo indice di k+1.

La ricorsione dovrebbe arrestarsi una volta che la somma parziale è maggiore o uguale al #numero desiderato di lunghezze del libro. A questo punto, abbiamo fatto un libro troppo lontano, quindi torniamo k-1. La condizione è 1/2 * N/D < #; moltiplicando il denominatore, otteniamo N < D*#*2, che è il modo più golfoso per scriverlo.

La funzione helper ricorsivo _esegue tutti questi calcoli; la funzione principale è soltanto un unico involucro argomento che chiamate _con i valori iniziali corretti per k, Ne D.

— DLosc
fonte

Voglio che il mio libro sia lontano da questo tavolo

Ottava , 41 40 33 byte

Spiegazione

Python 3 , 35 byte

Buccia , 8 byte

Spiegazione

JavaScript, 30 byte

Haskell, 38 byte

Rapido , 65 byte

Ungolfed

R , 39 byte

Javascript (ES6), 34 byte

Ungolfed

Casi test

Gelatina , 8 byte

Haskell, 71 49 48 byte

Julia 0.6 , 30 27 byte

TI-BASIC, 27 byte

05AB1E , 11 byte

Pyth , 10 byte

Pyth , 10 byte

Japt , 12 byte

Spiegazione

J, 22 byte

risposta originale

Ungolfed

Spiegazione

PHP, 35 byte

Wolfram Language (Mathematica) , 40 byte

Java 8, 49 byte

tinylisp , 98 byte

Spiegazione