Encuentra la suma de N términos de la serie 0.1, 0.11, 0.111, …

Dado un entero positivo, N . Encuentre la suma del primer N término de la serie-

 0.1, 0.11, 0.111, 0.1111, ….hasta N términos

Ejemplos:

Entrada: N = 6
Salida: 0,654321

Entrada: N = 1
Salida: 0,1

 

Acercarse:

1er término = 0.1

2do término = 0.11

3er término = 0.111

4to término = 0.1111

.

.

N-ésimo término = 1/9(1 – (1/10) ^ N)

La secuencia se forma usando el siguiente patrón. Para cualquier valor N-

S_{N}=\frac{1}{9}(N-\frac{1}{9}(1-(\frac{1}{10})^{N}))

Derivación:

La siguiente serie de pasos se puede usar para derivar la fórmula para encontrar la suma de N términos:

La serie 0.1, 0.11, 0.111, … hasta N términos se puede escribir como

\frac{1}{9}(0,9+0,99+0,999+...+N términos)

\frac{1}{9}((1-0,1)+(1-0,11)+(1-0,111)+...+Ntérminos)

\frac{1}{9}((1+1+1+...+N)-(0.1+0.11+0.111+...+0.1^{N}))

\frac{1}{9}(N-(0,1+0,11+0,111+...+0,1^{N}))                  -(1)

La serie  0.1+0.11+0.111+...+0.1^{N}             está en GP con

Primer término a = 0.1 = 10 -1

Razón común r = 10 -1

La suma de GP para r<1 se puede expresar como:

S_{N}=\frac{a*(1-r^{N})}{1-r}

Sustituyendo los valores de a y r en la ecuación-

S_{N}=\frac{0.1*(1-0.1^{N})}{1-0.1}

S_{N}=\frac{1}{9}(1-(\frac{1}{10})^{N})                     -(2)

Sustituyendo la ecuación (2) en (1), obtenemos-

S_{N}=\frac{1}{9}(N-\frac{1}{9}(1-(\frac{1}{10})^{N}))

Ilustración:

Entrada: N = 6
Salida: 0,654321
Explicación:
S_{N}=\frac{1}{9}(N-\frac{1}{9}(1-(\frac{1}{10})^{N}))
S_{N}=\frac{1}{9}(6-\frac{1}{9}(1-(\frac{1}{10})^{6}))
S_{N}=\frac{1}{9}(6-0.111111)
S_{N}=\frac{1}{9}(5.888889)
S_{N}=0.654321

A continuación se muestra la implementación del enfoque anterior:

C++

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return sum of
// N term of the series
double findSum(int N)
{
    int a = pow(10, N);
    return (double)(N * 9 * a - a + 1)
           / (81 * a);
}
 
// Driver Code
int main()
{
    int N = 6;
    cout << findSum(N);
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
// Function to return sum of
// N term of the series
static double findSum(double N)
{
    double a = Math.pow(10, N);
    return (double)(N * 9 * a - a + 1)
           / (81 * a);
}
 
// Driver Code
    public static void main (String[] args) {
          double N = 6;
        System.out.print(findSum(N));
    }
}
 
// This code is contributed by hrithikgarg03188.

Python3

# Python 3 program for the above approach
 
# Function to return sum of
# N term of the series
def findSum(N):
    a = pow(10, N)
    return (N * 9 * a - a + 1) / (81 * a)
 
# Driver Code
if __name__ == "__main__":
   
    # Value of N
    N = 6   
    print(findSum(N))
 
# This code is contributed by Abhishek Thakur.

C#

// C# program to implement
// the above approach
using System;
class GFG
{
 
  // Function to return sum of
  // N term of the series
  static double findSum(int N)
  {
    int a = (int)Math.Pow(10, N);
    return (double)(N * 9 * a - a + 1)
      / (81 * a);
  }
 
  // Driver Code
  public static void Main()
  {
    int N = 6;
    Console.Write(findSum(N));
  }
}
 
// This code is contributed by Samim Hossain Mondal.

Javascript

<script>
        // JavaScript code for the above approach
 
        // Function to return sum of
        // N term of the series
        function findSum(N) {
            let a = Math.pow(10, N);
            return (N * 9 * a - a + 1)
                / (81 * a);
        }
 
        // Driver Code
        let N = 6;
        document.write(findSum(N));
 
       // This code is contributed by Potta Lokesh
    </script>
Producción

0.654321

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)

Publicación traducida automáticamente

Artículo escrito por akashjha2671 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *