Notifiche
Cancella tutti

Esercizio particolare sul calcolo di un limite

  

0

Salve a tutti, ho il seguente esercizio

image

dove con quel simbolo indico la parte intera di e^k/n.

Sfruttando la definizione di parte intera, ovvero il più grande intero minore o uguale al numero in questione, ho trovato che la successione è compresa tra 1 e 2, però poi non so come arrivare al calcolo del limite. Ho provato anche a dare alcuni valori ad n, per esempio per n=2 la successione vale 2, per altri valori di n invece abbiamo che la successione assume numeri strettamente compresi tra 1 e 2, non mi sembra neanche che sia crescente o decrescente, mi verrebbe da dire che questo limite non esiste. So che è un esercizio abbastanza laborioso, però vi sarei grato se qualcuno di voi potesse aiutarmi a risolverlo in modo rigoroso. Grazie a chi vorrà aiutarmi

Autore
Etichette discussione
3 Risposte
1

L'esercizio é semplicissimo, ma poiché non é standard occorre un pò di ragionamento. 

Se scrivi  1/n * ([ e^(1/n) ] + [ e^(2/n) ] + ... + [ e^(h/n) ] + ... [ e^(n/n) ] ) 

 

sarà facile rendersi conto che il generico addendo sarà sempre 1 fino a h e

poi sempre 2, essendo e^(h/n) = 2 => h/n = ln 2 => h = n ln 2 .

 

Dovrai dunque calcolare il lim_n->oo [ 1* n ln 2 + 2* (n - n ln 2) ]/n = 

= lim_n->oo n/n [ ln 2 + 2 - 2 ln 2 ] = 2 - ln 2 ~ 1.307.

Quando n->oo gli effetti di bordo legati al fatto che n ln 2 non é intero tendono a scomparire.

Buona serata.

@eidosm non ho capito bene il tuo ragionamento. Il fatto che per un certo indice la parte intera valga 1 mi è chiaro, ci ero arrivato anch'io. Però poi tu poni che e^(h/n)=2, ma questo è falso, poichè è la parte intera che vale 2 non l'esponenziale come hai scritto. Non mi sono chiari i passaggi che hai usato. Inoltre come si determinerebbe questo h per un generico n?

e^(k/n) é sempre crescente al crescere di k. Arriverà un valore, e sia h, dopo il quale 

e^(k/n) é maggiore di 2 e la parte intera sarà sempre 2 fino all'ultimo termine, [ e ] = 2.

Il valore dell'esponenziale non sarà 2 per un h intero, ma dopo l'ultimo k per cui é minore di 2

la parte intera é sempre 2.

@eidosm si ma tu hai scritto nella soluzione e^(h/n)=2, avresti dovuto scrivere e^(h/n)>2, quindi troveresti h>n ln2. Continuo a non capire perchè hai scritto h=n ln2.

Ok, ad essere pignoli, h = [ n ln 2 ]. E vedrai che il resto quadra.

@eidosm da quello che ho visto sarebbe h=[n ln2]+1. Però il conto non mi è chiaro come verrebbe fuori, ci sono delle proprietà della parte intera? Vabene che così ci troviamo, però il calcolo rigoroso quale sarebbe?

@eidosm tu tra l'altro nel conto tralasci la parte intera, fai finta che non c'è

h é l'ultimo k per cui [ e^(k/n) ] = 1 e quindi é quello per cui h/n é l'ultimo prima di x :

e^x = 2 => x = ln 2. E' vero che non ho considerato la parte intera ma ciò non incide sul limite perché la differenza  n ln 2 - [ n ln 2 ] é minore di 1 e divisa per n determina un infinitesimo.

@eidosm scusa ma non ti seguo proprio. Grazie comunque dell'aiuto.

@eidosm anche se il tuo ragionamento non l'ho capito, mi hai dato l'idea per poter impostare un mio di ragionamento che mi ha portato a calcolare il limite. Se supponiamo che per k che va da 1 ad h la parte intera vale 1, mentre per k che va da h+1 a n vale 2. Quindi il limite da calcolare è limite di n che tende a più infinito di (1/n)[h+2(n-h)]=2-h/n. Sappiamo che e^(h/n)<2, mentre e^((h+1)/n)>2, quindi h/n <ln2 e (h+1)/n >ln2 cioè h/n > ln2-1/n. Applico il criterio del confronto e ottengo che il limite vale ciò che mi avevi detto tu ovvero 2-ln2.

Sì, può essere scritto così.




0

L'n-mo termine della successione
* a(n) = (1/n)*(Σ [k = 1, n] floor(e^(k/n)))
è il valor medio degli n addendi floor(e^(k/n)).
Copio qui di seguito cosa ho fatto nell'IDLE di Python
==============================
Python 2.7.14 (v2.7.14:84471935ed, Sep 16 2017, 2030) [MSC v.1500 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> def apprentus(u):
import math
result = []
for n in range(1, u + 1):
addendi = []
den = float(n)
for k in range(1, n + 1): addendi.append(int(math.floor(math.exp(k/den))))
media = sum(addendi)/den
result.append((n, addendi, media))
return result

>>> apprentus(12)
[(1, [2], 2.0), (2, [1, 2], 1.5), (3, [1, 1, 2], 1.3333333333333333), (4, [1, 1, 2, 2], 1.5), (5, [1, 1, 1, 2, 2], 1.4), (6, [1, 1, 1, 1, 2, 2], 1.3333333333333333), (7, [1, 1, 1, 1, 2, 2, 2], 1.4285714285714286), (8, [1, 1, 1, 1, 1, 2, 2, 2], 1.375), (9, [1, 1, 1, 1, 1, 1, 2, 2, 2], 1.3333333333333333), (10, [1, 1, 1, 1, 1, 1, 2, 2, 2, 2], 1.4), (11, [1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2], 1.3636363636363635), (12, [1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2], 1.3333333333333333)]
>>>
------------------------------
(n, {floor(e^(k/n))}, a(n))
(1, [2], 2.0),
(2, [1, 2], 1.5),
(3, [1, 1, 2], 1.3333333333333333),
(4, [1, 1, 2, 2], 1.5),
(5, [1, 1, 1, 2, 2], 1.4),
(6, [1, 1, 1, 1, 2, 2], 1.3333333333333333),
(7, [1, 1, 1, 1, 2, 2, 2], 1.4285714285714286),
(8, [1, 1, 1, 1, 1, 2, 2, 2], 1.375),
(9, [1, 1, 1, 1, 1, 1, 2, 2, 2], 1.3333333333333333),
(10, [1, 1, 1, 1, 1, 1, 2, 2, 2, 2], 1.4),
(11, [1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2], 1.3636363636363635),
(12, [1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2], 1.3333333333333333)
==============================
Visualizzare il segmento iniziale di {a(n)}, in particolare i paragrafi "Plot" e "Cumulative sums" al link
https://www.wolframalpha.com/input?i=2%2C3%2F2%2C4%2F3%2C3%2F2%2C7%2F5%2C4%2F3%2C10%2F7%2C11%2F8%2C4%2F3%2C7%2F5%2C15%2F11%2C4%2F3%2C...
mi suggerisce un paio d'idee.
---------------
1) interpolare la cumulata
* {2, 7/2, 29/6, 19/3, 116/15, 136/15, 1102/105, 9971/840, 3697/280, 4089/280, 49179/3080, 159857/9240}
con la retta
* s(n) = 1.38844*n + 0.717413
di pendenza che differisce da 4/3 solo del
* (34711/25000 - 4/3)/(4/3) = 4133/100000 ~= 4%
---------------
2) che converrebbe, osservando gli a(n) in terne con indici multipli di (1, 2, 3),
2, 3/2, 4/3,
3/2, 7/5, 4/3,
10/7, 11/8, 4/3,
7/5, 15/11, 4/3, ...
estendere il segmento iniziale di un bel po' (fino a n = 51?) e poi cercare la legge di formazione per la prima e la seconda colonna della tavola delle terne lasciando fisso il 4/3 nella terza colonna (che dovrebbe risultare il limite della successione).
Per quel poco che può valere, vedi ai link
http://www.wolframalpha.com/input?i=2%2C3%2F2%2C10%2F7%2C7%2F5%2C...
http://www.wolframalpha.com/input?i=3%2F2%2C7%2F5%2C11%2F8%2C15%2F11%2C...

 

0
octave:1> n = 10;
octave:2> s = 0;
octave:3> for k=1:n,
> > s = s + floor(e^(k/n));
> > endfor
octave:4> m = s/n
m = 1.4000
octave:5> n = 100;
octave:6> s = 0;
octave:7> for k=1:n,
> > s = s + floor(e^(k/n));
> > endfor
octave:8> m = s/n
m = 1.3100
octave:9> n = 1000;
octave:10> s = 0;
octave:11> for k=1:n,
> > s = s + floor(e^(k/n));
> > endfor
octave:12> m = s/n
m = 1.3070
octave:13> n = 10000;
octave:14> s = 0;
octave:15> for k=1:n,
> > s = s + floor(e^(k/n));
> > endfor
octave:16> m = s/n
m = 1.3069
Ecco uno sviluppo algoritmico per valori crescenti di n 
Con 4 cifre decimali esatte 2 - ln 2 = 1.3069
 
 
 
 
 
 
 
 




Risposta



About SosMatematica

Seguici su:

Scarica la nostra App Ufficiale

SOS Matematica

GRATIS
VISUALIZZA