Find n-th term in series 1 2 2 3 3 3 4 4 4 4….
Last Updated :
15 Feb, 2024
Given series 1 2 2 3 3 3 4 4 4 4 …., find n-th term of the series. The “pattern” is obvious. There is one “1”, two “2”s three “3”s, etc.
Examples:
Input : n = 5
Output : 3
Input : n = 7
Output : 4
A naive approach is to run two loops one from 1 to n and the other from 1 to i, and for every iteration of the inner loop keep a count, whenever the count reaches n, we can break out of both the loops and i will be our answer.
C++
#include <bits/stdc++.h>
using namespace std;
int term( int n) {
int count = 0;
int result = 0;
for ( int i = 1; i <= n; ++i) {
for ( int j = 1; j <= i; ++j) {
++count;
if (count == n) {
result = i;
break ;
}
}
if (count == n) {
break ;
}
}
return result;
}
int main() {
int n = 5;
cout<<term(n);
return 0;
}
|
Java
public class SeriesTerm {
static int term( int n) {
int count = 0 ;
int result = 0 ;
for ( int i = 1 ; i <= n; ++i) {
for ( int j = 1 ; j <= i; ++j) {
++count;
if (count == n) {
result = i;
break ;
}
}
if (count == n) {
break ;
}
}
return result;
}
public static void main(String[] args) {
int n = 5 ;
System.out.println(term(n));
}
}
|
Python3
def term(n):
count = 0
result = 0
for i in range ( 1 , n + 1 ):
for j in range ( 1 , i + 1 ):
count + = 1
if count = = n:
result = i
break
if count = = n:
break
return result
n = 5
print (term(n))
|
C#
using System;
class Program
{
static int Term( int n)
{
int count = 0;
int result = 0;
for ( int i = 1; i <= n; ++i)
{
for ( int j = 1; j <= i; ++j)
{
++count;
if (count == n)
{
result = i;
break ;
}
}
if (count == n)
{
break ;
}
}
return result;
}
static void Main()
{
int n = 5;
Console.WriteLine(Term(n));
}
}
|
Javascript
function term(n) {
let count = 0;
let result = 0;
for (let i = 1; i <= n; ++i) {
for (let j = 1; j <= i; ++j) {
++count;
if (count === n) {
result = i;
break ;
}
}
if (count === n) {
break ;
}
}
return result;
}
let n = 5;
console.log(term(n));
|
Time Complexity: O(n), as we will be using a loop to traverse n times.
Auxiliary Space: O(1), as we will not be using any extra space.
Efficient Approach:
An efficient approach will be to note down a small observation which is:
The trick is to find a pattern.
Consider numbering the given sequence as follows:
1 is at position 1
2 is at positions 2, 3
3 is at positions 4, 5, 6
4 is at positions 7, 8, 9, 10
and so on…
Notice that the last positions of the individual values form a sequence.
1, 3, 6, 10, 15, 21…
If we want a formula for the “nth” term, start by looking at it the other way around. In which term does the number “n” first appear? Taking the first term to be the “0th” term. “1” appears in term 0, “2” appears in term 1, “3” appears in term 1+2=3, “4” appears in term 1+2+3= 6, etc. The number “x” first appears in term 1 + 2 + …+ (x- 2)+ (x-1) = x(x-1)/2.
So solving for the n-th term we get n = x*(x-1)/2
Solving it using quadratic equation we get
x = ( ( 1 + sqrt(1+8*n) )/2 )
n in every case is NOT an integer which means the n-th number is not the first of a sequence of the same integer, but it is clear that the n-th integer is the integer value.
C++
#include <bits/stdc++.h>
using namespace std;
int term( int n)
{
int x = (((1) + ( double ) sqrt (1 + (8 * n))) / 2);
return x;
}
int main()
{
int n = 5;
cout << term(n);
return 0;
}
|
Java
import java.io.*;
class Series {
static int term( int n)
{
int x = ((( 1 ) + ( int )Math.sqrt( 1 +
( 8 * n))) / 2 );
return x;
}
public static void main (String[] args) {
int n = 5 ;
System.out.println(term(n));
}
}
|
Python3
import math
def term( n ):
x = ((( 1 ) + math.sqrt( 1 + ( 8 * n))) / 2 )
return x
n = 5
print ( int (term(n)))
|
C#
using System;
class Series
{
static int term( int n)
{
int x = (((1) + ( int )Math.Sqrt(1 + (8 * n))) / 2);
return x;
}
public static void Main()
{
int n = 5;
Console.WriteLine(term(n));
}
}
|
Javascript
<script>
function term(n)
{
let x = parseInt(((1) + Math.sqrt(1 + (8 * n))) / 2);
return x;
}
let n = 5;
document.write(term(n));
</script>
|
PHP
<?php
function term( $n )
{
$x = (((1) + (double)sqrt(1 +
(8 * $n ))) / 2);
return $x ;
}
$n = 5;
echo ((int)term( $n ));
?>
|
Time Complexity: O(log(n)) as sqrt function takes O(log n).
Auxiliary Space: O(1), as we are not using any extra space.
Another Efficient Approach:
Another efficient approach is to find another pattern related to first and last position index of every number.
Pattern:
Consider numbering the given sequence as follows:
1 is at position 1
2 is at positions 2, 3
3 is at positions 4, 5, 6
4 is at positions 7, 8, 9, 10
5 is at positions 11, 12, 13, 14, 15
6 is at positions 16, 17, 18, 19, 20, 21
7 is at positions 22, 23, 24, 25, 26, 27, 28
and so on…
From the above notice that the first or last positions of the individual values are either their sqrt(2*first or last position) or 1+sqrt(2*first or last position), means
X = sqrt(2n) or 1+sqrt(2n)
For the above pattern let’s do the implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int term( int n)
{
int x = sqrt (2 * n);
if (((x * x) - x + 2) <= 2 * n
&& ((x * x) + x) >= 2 * n)
return x;
else
return x + 1;
}
int main()
{
int n = 5;
cout << term(n);
return 0;
}
|
Java
import java.util.Scanner;
public class Main {
static int findNthTerm( int n)
{
int x = ( int )Math.sqrt( 2 * n);
if (((x * x) - x + 2 ) <= 2 * n
&& ((x * x) + x) >= 2 * n)
return x;
else
return x + 1 ;
}
public static void main(String[] args)
{
int n = 5 ;
System.out.println(findNthTerm(n));
}
}
|
Python3
import math
def term(n):
x = int (math.sqrt( 2 * n))
if ((x * x) - x + 2 ) < = 2 * n and ((x * x) + x) > = 2 * n:
return x
else :
return x + 1
n = 5
print (term(n))
|
C#
using System;
class Program {
static int Term( int n)
{
int x = ( int )Math.Sqrt(2 * n);
if (((x * x) - x + 2) <= 2 * n
&& ((x * x) + x) >= 2 * n)
return x;
else
return x + 1;
}
static void Main()
{
int n = 5;
Console.WriteLine(Term(n));
}
}
|
Javascript
function term(n) {
const x = Math.sqrt(2 * n);
if (((x * x) - x + 2) <= 2 * n && ((x * x) + x) >= 2 * n) {
return Math.floor(x);
} else {
return Math.floor(x) + 1;
}
}
const n = 5;
console.log(term(n));
|
Time Complexity: O(log(n)) as sqrt function takes O(log n).
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...