Check that if large number is divisible by 24

Here given code implementation process.

// Java program for
// Check that if large number is divisible by 24
public class Divisibility
{
	public void isDivisibleBy24(String num)
	{
		// Rule
		// ➀ number is divisible by 3 and
		// ➁ number is divisible by 8
		boolean result = false;
		int n = num.length();
		int auxiliary = 0;
		if (n == 1 && num.charAt(0) == '0')
		{
			result = true;
		}
		else
		{
			// Check number is divisible by 3 or not
			int sum = 0;
			// Calculate sum of all digit
			for (int i = 0; i < n; ++i)
			{
				sum += (num.charAt(i) - 48);
			}
			if (sum % 3 == 0)
			{
				// When number divisible by 3
				// Check number is divisible by 8 or not
				if (n == 2)
				{
					auxiliary = num.charAt(n - 2) * 10 + num.charAt(n - 1);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
				else if (n > 2)
				{
					// Get last three digit number
					auxiliary = ((num.charAt(n - 3) - 48) * 10 + 
                                 (num.charAt(n - 2) - 48)) * 10 + 
                      (num.charAt(n - 1) - 48);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
			}
		}
		if (result)
		{
			System.out.println(" Given number (" + 
                               num + ") is divisible by 24");
		}
		else
		{
			System.out.println(" Given number (" + 
                               num + ") is not divisible by 24");
		}
	}
	public static void main(String[] args)
	{
		Divisibility task = new Divisibility();
		// Test
		task.isDivisibleBy24("45645624");
		task.isDivisibleBy24("56456423434545645567567567867816");
		task.isDivisibleBy24("5654464564564564512320");
		task.isDivisibleBy24("56456423434545645567567567867824");
		task.isDivisibleBy24("967345345365543456");
	}
}

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

// Include header file
#include <iostream>
#include <string>

using namespace std;
// C++ program for
// Check that if large number is divisible by 24
class Divisibility
{
	public: void isDivisibleBy24(string num)
	{
		// Rule
		// ➀ number is divisible by 3 and
		// ➁ number is divisible by 8
		bool result = false;
		int n = num.length();
		int auxiliary = 0;
		if (n == 1 && num[0] == '0')
		{
			result = true;
		}
		else
		{
			// Check number is divisible by 3 or not
			int sum = 0;
			// Calculate sum of all digit
			for (int i = 0; i < n; ++i)
			{
				sum += (num[i] - 48);
			}
			if (sum % 3 == 0)
			{
				// When number divisible by 3
				// Check number is divisible by 8 or not
				if (n == 2)
				{
					auxiliary = num[n - 2] *10 + num[n - 1];
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
				else if (n > 2)
				{
					// Get last three digit number
					auxiliary = ((num[n - 3] - 48) *10 + 
                                 (num[n - 2] - 48)) *10 + 
                      (num[n - 1] - 48);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
			}
		}
		if (result)
		{
			cout << " Given number (" 
          		<< num << ") is divisible by 24" << endl;
		}
		else
		{
			cout << " Given number (" 
          		 << num << ") is not divisible by 24" << endl;
		}
	}
};
int main()
{
	Divisibility *task = new Divisibility();
	// Test
	task->isDivisibleBy24("45645624");
	task->isDivisibleBy24("56456423434545645567567567867816");
	task->isDivisibleBy24("5654464564564564512320");
	task->isDivisibleBy24("56456423434545645567567567867824");
	task->isDivisibleBy24("967345345365543456");
	return 0;
}

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

// Include namespace system
using System;
// Csharp program for
// Check that if large number is divisible by 24
public class Divisibility
{
	public void isDivisibleBy24(String num)
	{
		// Rule
		// ➀ number is divisible by 3 and
		// ➁ number is divisible by 8
		Boolean result = false;
		int n = num.Length;
		int auxiliary = 0;
		if (n == 1 && num[0] == '0')
		{
			result = true;
		}
		else
		{
			// Check number is divisible by 3 or not
			int sum = 0;
			// Calculate sum of all digit
			for (int i = 0; i < n; ++i)
			{
				sum += (num[i] - 48);
			}
			if (sum % 3 == 0)
			{
				// When number divisible by 3
				// Check number is divisible by 8 or not
				if (n == 2)
				{
					auxiliary = num[n - 2] * 10 + num[n - 1];
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
				else if (n > 2)
				{
					// Get last three digit number
					auxiliary = ((num[n - 3] - 48) * 10 + 
                                 (num[n - 2] - 48)) * 10 + 
                      (num[n - 1] - 48);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
			}
		}
		if (result)
		{
			Console.WriteLine(" Given number (" + 
                              num + ") is divisible by 24");
		}
		else
		{
			Console.WriteLine(" Given number (" + 
                              num + ") is not divisible by 24");
		}
	}
	public static void Main(String[] args)
	{
		Divisibility task = new Divisibility();
		// Test
		task.isDivisibleBy24("45645624");
		task.isDivisibleBy24("56456423434545645567567567867816");
		task.isDivisibleBy24("5654464564564564512320");
		task.isDivisibleBy24("56456423434545645567567567867824");
		task.isDivisibleBy24("967345345365543456");
	}
}

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

package main
import "fmt"
// Go program for
// Check that if large number is divisible by 24

func isDivisibleBy24(num string) {
	// Rule
	// ➀ number is divisible by 3 and
	// ➁ number is divisible by 8
	var result bool = false
	var n int = len(num)
	var auxiliary int = 0
	if n == 1 && num[0] == '0' {
		result = true
	} else {
		// Check number is divisible by 3 or not
		var sum int = 0
		// Calculate sum of all digit
		for i := 0 ; i < n ; i++ {
			sum += (int(num[i]) - 48)
		}
		if sum % 3 == 0 {
			// When number divisible by 3
			// Check number is divisible by 8 or not
			if n == 2 {
				auxiliary = int(num[n - 2]) * 10 + int(num[n - 1])
				if auxiliary % 8 == 0 {
					result = true
				}
			} else if n > 2 {
				// Get last three digit number
				auxiliary = ((int(num[n - 3]) - 48) * 10 + 
					(int(num[n - 2]) - 48)) * 10 + 
				(int(num[n - 1]) - 48)
				if auxiliary % 8 == 0 {
					result = true
				}
			}
		}
	}
	if result {
		fmt.Println(" Given number (", num, ") is divisible by 24")
	} else {
		fmt.Println(" Given number (", num, ") is not divisible by 24")
	}
}
func main() {

	// Test
	isDivisibleBy24("45645624")
	isDivisibleBy24("56456423434545645567567567867816")
	isDivisibleBy24("5654464564564564512320")
	isDivisibleBy24("56456423434545645567567567867824")
	isDivisibleBy24("967345345365543456")
}

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

<?php
// Php program for
// Check that if large number is divisible by 24
class Divisibility
{
	public	function isDivisibleBy24($num)
	{
		// Rule
		// ➀ number is divisible by 3 and
		// ➁ number is divisible by 8
		$result = false;
		$n = strlen($num);
		$auxiliary = 0;
		if ($n == 1 && $num[0] == '0')
		{
			$result = true;
		}
		else
		{
			// Check number is divisible by 3 or not
			$sum = 0;
			// Calculate sum of all digit
			for ($i = 0; $i < $n; ++$i)
			{
				$sum += (ord($num[$i]) - 48);
			}
			if ($sum % 3 == 0)
			{
				// When number divisible by 3
				// Check number is divisible by 8 or not
				if ($n == 2)
				{
					$auxiliary = ord($num[$n - 2]) * 10 + ord($num[$n - 1]);
					if ($auxiliary % 8 == 0)
					{
						$result = true;
					}
				}
				else if ($n > 2)
				{
					// Get last three digit number
					$auxiliary = ((ord($num[$n - 3]) - 48) * 10 + 
                                  (ord($num[$n - 2]) - 48)) * 10 + 
                      (ord($num[$n - 1]) - 48);
					if ($auxiliary % 8 == 0)
					{
						$result = true;
					}
				}
			}
		}
		if ($result)
		{
			echo(" Given number (".$num.
				") is divisible by 24\n");
		}
		else
		{
			echo(" Given number (".$num.
				") is not divisible by 24\n");
		}
	}
}

function main()
{
	$task = new Divisibility();
	// Test
	$task->isDivisibleBy24("45645624");
	$task->isDivisibleBy24("56456423434545645567567567867816");
	$task->isDivisibleBy24("5654464564564564512320");
	$task->isDivisibleBy24("56456423434545645567567567867824");
	$task->isDivisibleBy24("967345345365543456");
}
main();

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

// Node JS program for
// Check that if large number is divisible by 24
class Divisibility
{
	isDivisibleBy24(num)
	{
		// Rule
		// ➀ number is divisible by 3 and
		// ➁ number is divisible by 8
		var result = false;
		var n = num.length;
		var auxiliary = 0;
		if (n == 1 && num.charAt(0) == '0')
		{
			result = true;
		}
		else
		{
			// Check number is divisible by 3 or not
			var sum = 0;
			// Calculate sum of all digit
			for (var i = 0; i < n; ++i)
			{
				sum += (num.charCodeAt(i) - 48);
			}
			if (sum % 3 == 0)
			{
				// When number divisible by 3
				// Check number is divisible by 8 or not
				if (n == 2)
				{
					auxiliary = num.charCodeAt(n - 2) * 10 + 
                      num.charCodeAt(n - 1);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
				else if (n > 2)
				{
					// Get last three digit number
					auxiliary = ((num.charCodeAt(n - 3) - 48) * 10 + 
                                 (num.charCodeAt(n - 2) - 48)) * 10 + 
                      (num.charCodeAt(n - 1) - 48);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
			}
		}
		if (result)
		{
			console.log(" Given number (" + 
                        num + ") is divisible by 24");
		}
		else
		{
			console.log(" Given number (" + 
                        num + ") is not divisible by 24");
		}
	}
}

function main()
{
	var task = new Divisibility();
	// Test
	task.isDivisibleBy24("45645624");
	task.isDivisibleBy24("56456423434545645567567567867816");
	task.isDivisibleBy24("5654464564564564512320");
	task.isDivisibleBy24("56456423434545645567567567867824");
	task.isDivisibleBy24("967345345365543456");
}
main();

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

#  Python 3 program for
#  Check that if large number is divisible by 24
class Divisibility :
	def isDivisibleBy24(self, num) :
		#  Rule
		#  ➀ number is divisible by 3 and
		#  ➁ number is divisible by 8
		result = False
		n = len(num)
		auxiliary = 0
		if (n == 1 and num[0] == '0') :
			result = True
		else :
			#  Check number is divisible by 3 or not
			sum = 0
			i = 0
			#  Calculate sum of all digit
			while (i < n) :
				sum += (ord(num[i]) - 48)
				i += 1
			
			if (sum % 3 == 0) :
				#  When number divisible by 3
				#  Check number is divisible by 8 or not
				if (n == 2) :
					auxiliary = ord(num[n - 2]) * 10 + ord(num[n - 1])
					if (auxiliary % 8 == 0) :
						result = True
					
				elif (n > 2) :
					#  Get last three digit number
					auxiliary = ((ord(num[n - 3]) - 48) * 10 + 
                                 (ord(num[n - 2]) - 48)) * 10 + (ord(num[n - 1]) - 48)
					if (auxiliary % 8 == 0) :
						result = True
					
				
			
		
		if (result) :
			print(" Given number (", num ,") is divisible by 24")
		else :
			print(" Given number (", num ,") is not divisible by 24")
		
	

def main() :
	task = Divisibility()
	#  Test
	task.isDivisibleBy24("45645624")
	task.isDivisibleBy24("56456423434545645567567567867816")
	task.isDivisibleBy24("5654464564564564512320")
	task.isDivisibleBy24("56456423434545645567567567867824")
	task.isDivisibleBy24("967345345365543456")

if __name__ == "__main__": main()

Output

 Given number ( 45645624 ) is divisible by 24
 Given number ( 56456423434545645567567567867816 ) is divisible by 24
 Given number ( 5654464564564564512320 ) is not divisible by 24
 Given number ( 56456423434545645567567567867824 ) is not divisible by 24
 Given number ( 967345345365543456 ) is divisible by 24

#  Ruby program for
#  Check that if large number is divisible by 24
class Divisibility 
	def isDivisibleBy24(num) 
		#  Rule
		#  ➀ number is divisible by 3 and
		#  ➁ number is divisible by 8
		result = false
		n = num.length
		auxiliary = 0
		if (n == 1 && num[0] == '0') 
			result = true
		else
 
			#  Check number is divisible by 3 or not
			sum = 0
			i = 0
			#  Calculate sum of all digit
			while (i < n) 
				sum += (num[i].ord - 48)
				i += 1
			end

			if (sum % 3 == 0) 
				#  When number divisible by 3
				#  Check number is divisible by 8 or not
				if (n == 2) 
					auxiliary = num[n - 2].ord * 10 + num[n - 1].ord
					if (auxiliary % 8 == 0) 
						result = true
					end

				elsif (n > 2) 
					#  Get last three digit number
					auxiliary = ((num[n - 3].ord - 48) * 10 + 
                                 (num[n - 2].ord - 48)) * 10 + 
                      (num[n - 1].ord - 48)
					if (auxiliary % 8 == 0) 
						result = true
					end

				end

			end

		end

		if (result) 
			print(" Given number (", num ,") is divisible by 24\n")
		else
 
			print(" Given number (", num ,") is not divisible by 24\n")
		end

	end

end

def main() 
	task = Divisibility.new()
	#  Test
	task.isDivisibleBy24("45645624")
	task.isDivisibleBy24("56456423434545645567567567867816")
	task.isDivisibleBy24("5654464564564564512320")
	task.isDivisibleBy24("56456423434545645567567567867824")
	task.isDivisibleBy24("967345345365543456")
end

main()

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

// Scala program for
// Check that if large number is divisible by 24
class Divisibility()
{
	def isDivisibleBy24(num: String): Unit = {
		// Rule
		// ➀ number is divisible by 3 and
		// ➁ number is divisible by 8
		var result: Boolean = false;
		var n: Int = num.length();
		var auxiliary: Int = 0;
		if (n == 1 && num.charAt(0) == '0')
		{
			result = true;
		}
		else
		{
			// Check number is divisible by 3 or not
			var sum: Int = 0;
			var i: Int = 0;
			// Calculate sum of all digit
			while (i < n)
			{
				sum += (num.charAt(i).toInt - 48);
				i += 1;
			}
			if (sum % 3 == 0)
			{
				// When number divisible by 3
				// Check number is divisible by 8 or not
				if (n == 2)
				{
					auxiliary = num.charAt(n - 2).toInt * 10 + 
                      num.charAt(n - 1).toInt;
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
				else if (n > 2)
				{
					// Get last three digit number
					auxiliary = ((num.charAt(n - 3).toInt - 48) * 10 + 
                                 (num.charAt(n - 2).toInt - 48)) * 10 + 
                      (num.charAt(n - 1).toInt - 48);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
			}
		}
		if (result)
		{
			println(" Given number (" + num + ") is divisible by 24");
		}
		else
		{
			println(" Given number (" + num + ") is not divisible by 24");
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Divisibility = new Divisibility();
		// Test
		task.isDivisibleBy24("45645624");
		task.isDivisibleBy24("56456423434545645567567567867816");
		task.isDivisibleBy24("5654464564564564512320");
		task.isDivisibleBy24("56456423434545645567567567867824");
		task.isDivisibleBy24("967345345365543456");
	}
}

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

import Foundation;
// Swift 4 program for
// Check that if large number is divisible by 24
class Divisibility
{
	func isDivisibleBy24(_ x: String)
	{
      	let num = Array(x);
		// Rule
		// ➀ number is divisible by 3 and
		// ➁ number is divisible by 8
		var result: Bool = false;
		let n: Int = num.count;
		var auxiliary: Int = 0;
		if (n == 1 && num[0] == "0")
		{
			result = true;
		}
		else
		{
			// Check number is divisible by 3 or not
			var sum: Int = 0;
			var i: Int = 0;
			// Calculate sum of all digit
			while (i < n)
			{
				sum += (Int(UnicodeScalar(String(num[i]))!.value) - 48);
				i += 1;
			}
			if (sum % 3 == 0)
			{
				// When number divisible by 3
				// Check number is divisible by 8 or not
				if (n == 2)
				{
					auxiliary = Int(UnicodeScalar(
                      String(num[n - 2]))!.value) * 10 + 
                      Int(UnicodeScalar(
                      String(num[n - 1]))!.value);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
				else if (n > 2)
				{
					// Get last three digit number
					auxiliary = ((Int(UnicodeScalar(
                      String(num[n - 3]))!.value) - 48) * 10 + 
                                 (Int(UnicodeScalar(
                      String(num[n - 2]))!.value) - 48)) * 10 + 
                      (Int(UnicodeScalar(
                      String(num[n - 1]))!.value) - 48);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
			}
		}
		if (result)
		{
			print(" Given number (", x ,") is divisible by 24");
		}
		else
		{
			print(" Given number (", x ,") is not divisible by 24");
		}
	}
}
func main()
{
	let task: Divisibility = Divisibility();
	// Test
	task.isDivisibleBy24("45645624");
	task.isDivisibleBy24("56456423434545645567567567867816");
	task.isDivisibleBy24("5654464564564564512320");
	task.isDivisibleBy24("56456423434545645567567567867824");
	task.isDivisibleBy24("967345345365543456");
}
main();

Output

 Given number ( 45645624 ) is divisible by 24
 Given number ( 56456423434545645567567567867816 ) is divisible by 24
 Given number ( 5654464564564564512320 ) is not divisible by 24
 Given number ( 56456423434545645567567567867824 ) is not divisible by 24
 Given number ( 967345345365543456 ) is divisible by 24

// Kotlin program for
// Check that if large number is divisible by 24
class Divisibility
{
	fun isDivisibleBy24(num: String): Unit
	{
		// Rule
		// ➀ number is divisible by 3 and
		// ➁ number is divisible by 8
		var result: Boolean = false;
		val n: Int = num.length;
		var auxiliary: Int;
		if (n == 1 && num.get(0) == '0')
		{
			result = true;
		}
		else
		{
			// Check number is divisible by 3 or not
			var sum: Int = 0;
			var i: Int = 0;
			// Calculate sum of all digit
			while (i < n)
			{
				sum += (num.get(i).toInt() - 48);
				i += 1;
			}
			if (sum % 3 == 0)
			{
				// When number divisible by 3
				// Check number is divisible by 8 or not
				if (n == 2)
				{
					auxiliary = num.get(n - 2).toInt() * 10 + 
                      num.get(n - 1).toInt();
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
				else if (n > 2)
				{
					// Get last three digit number
					auxiliary = ((num.get(n - 3).toInt() - 48) * 10 + 
                                 (num.get(n - 2).toInt() - 48)) * 10 + 
                      (num.get(n - 1).toInt() - 48);
					if (auxiliary % 8 == 0)
					{
						result = true;
					}
				}
			}
		}
		if (result)
		{
			println(" Given number (" + num + ") is divisible by 24");
		}
		else
		{
			println(" Given number (" + num + ") is not divisible by 24");
		}
	}
}
fun main(args: Array < String > ): Unit
{
	val task: Divisibility = Divisibility();
	// Test
	task.isDivisibleBy24("45645624");
	task.isDivisibleBy24("56456423434545645567567567867816");
	task.isDivisibleBy24("5654464564564564512320");
	task.isDivisibleBy24("56456423434545645567567567867824");
	task.isDivisibleBy24("967345345365543456");
}

Output

 Given number (45645624) is divisible by 24
 Given number (56456423434545645567567567867816) is divisible by 24
 Given number (5654464564564564512320) is not divisible by 24
 Given number (56456423434545645567567567867824) is not divisible by 24
 Given number (967345345365543456) is divisible by 24

« Previous Next »

Mathematics

Calculate simple interest

Calculate compound interest

Check leap year

Split a number into three parts

Sum of n natural numbers

Sum of n fibonacci numbers

Generating Pythagorean Triples

Modular multiplicative inverse

Find the sum of geometric series

Print the given geometric progression

Sum of natural numbers in a range

Generate multiplication table of given number

Find N-th element in geometric progression series

Sieve of eratosthenes

Sieve of Atkin

Sieve of Sundaram

Bitwise Sieve

Count digits in a factorial

Count all perfect divisors of a number

Count all x divisible number in a range

Count Even and Odd numbers in a range

Count factorial numbers in given range

Count the number of possible triangles

Count of common multiples of two numbers in a range

Print given row in pascal triangle

Check if the number is balanced

Find the composite numbers from 1 to n

Find largest multiple of 3 in array of digits

Babylonian method for square root

Check if a number is multiple of 5 or not

Calculate power without using division and multiplication

DFA based division

Check divisibility by 7 without modulus operator

Find the next smallest palindrome in an array

Find day of the week for a given date

Addition of two numbers by using prefix and postfix

Check if number is power of 4

Check if number is power of 3

Check whether a given number is an Polydivisible number or not

Check whether the given number is euclid number or not

Check whether the given number is moran number or not

Check whether the given number is nude number or not

Check whether the given number is buzz number or not

Find largest number without using relational operator

Find the minimum and maximum of integers without using branching

Find the absolute value of integer without using branching

Generating all sub sequence of an array of limited size

Generating all subarrays of an array

Find digital root of a large number efficiently

Sum of XOR of all subarrays

Sum of XOR of all possible subsets

Permutation coefficient program

Check if large number is divisible by 20

Check if large number is divisible by 6

Check if large number is divisible by 11

Check if large number is divisible by 3

Number divisible by 8 using bitwise

Number divisible by 9 using bitwise

Check if large number is divisible by 25

Two elements whose sum is closest to zero

Find the only repetitive number between 1 to n-1

Find most frequent element in an array by using sort

Sum of all integers between two integers

Find Newman–Shanks–Williams prime

Sum of n Fibonacci number in constant time

Sum of initial N Even natural numbers

Average of squares of natural numbers

Sum of squares of first n natural numbers

Sum of squares of first n natural numbers in constant time

Juggler Sequence

Find all numbers having digit product equal to k in 1 to N

Find perfect numbers in a given range

Multiply integer number with 3.5

Sum of cubes of n even natural numbers

Average of cubes of first n natural numbers

Moving average of array elements

Average of first n natural numbers

Checking whether a number is a power of 10

Find combination of k with consecutive absolute difference

Find two numbers whose sum is N and does not contain any digit as K

Find the sum of nth row in pascal's triangle

Segmented Sieve

Check that if large number is divisible by 2

Check that if large number is divisible by 10

Check that if large number is divisible by 9

Check that if large number is divisible by 30

Check that if large number is divisible by 999

Print all sophie germain primes less than n

Print safe prime numbers from 1 to n

Check if a number is full prime number

Find the prime numbers between given range using segmented sieve

Check that if large number is divisible by 15

Check that if large number is divisible by 18

Check that if large number is divisible by 22

Check that if large number is divisible by 12

Check that if large number is divisible by 7

Check that if large number is divisible by 8

Check that if large number is divisible by 24

Check that if large number is divisible by 13

Check that if large number is divisible by 16

Sum of all subarrays of an array efficiently

Determine that if given number is Fibonacci Number

Determine that if given number is full Fibonacci Number

Sum of minimum element of all subarrays of a sorted array

Sum the maximum element of all subarrays of a sorted array

Find index of fibonacci number

Replacing one digit with other in an integer

Generate all unique partitions of a number by iterative approach

Add of two polynomials using array

Multiply two polynomials

Russian peasant multiplication

Calculate factorial of large number

Find sum of digits in factorial of a number

Count all the multiples of 3 and 5 in the initial n natural numbers

Sum of all the multiples of 3 and 5 in n natural numbers

Reducing fractions to lowest terms

Sum of all the multiples of 3 and 7 in n natural numbers

Sum of the multiples of two numbers in n natural numbers

Find the all right truncatable primes in n natural numbers

Find the all left truncatable primes in n natural numbers

Find average without division

Addition of two octal numbers

Count the number of ways to cover given sum

Addition of two hexadecimal numbers

Find nearest Fibonacci number from given number

Find first digit of a number

Find last digit of a number

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment

Name