Count rotations divisible by 8
Last Updated :
09 Jun, 2022
Given a large positive number as string, count all rotations of the given number which are divisible by 8.
Examples:
Input: 8
Output: 1
Input: 40
Output: 1
Rotation: 40 is divisible by 8
04 is not divisible by 8
Input : 13502
Output : 0
No rotation is divisible by 8
Input : 43262488612
Output : 4
Approach: For large numbers it is difficult to rotate and divide each number by 8. Therefore, ‘divisibility by 8’ property is used which says that a number is divisible by 8 if the last 3 digits of the number is divisible by 8. Here we do not actually rotate the number and check last 8 digits for divisibility, instead we count consecutive sequence of 3 digits (in circular way) which are divisible by 8.
Illustration:
Consider a number 928160
Its rotations are 928160, 092816, 609281,
160928, 816092, 281609.
Now form consecutive sequence of 3-digits from
the original number 928160 as mentioned in the
approach.
3-digit: (9, 2, 8), (2, 8, 1), (8, 1, 6),
(1, 6, 0),(6, 0, 9), (0, 9, 2)
We can observe that the 3-digit number formed by
the these sets, i.e., 928, 281, 816, 160, 609, 092,
are present in the last 3 digits of some rotation.
Thus, checking divisibility of these 3-digit numbers
gives the required number of rotations.
C++
// C++ program to count all rotations divisible
// by 8
#include <bits/stdc++.h>
using namespace std;
// function to count of all rotations divisible
// by 8
int countRotationsDivBy8(string n)
{
int len = n.length();
int count = 0;
// For single digit number
if (len == 1) {
int oneDigit = n[0] - '0';
if (oneDigit % 8 == 0)
return 1;
return 0;
}
// For two-digit numbers (considering all
// pairs)
if (len == 2) {
// first pair
int first = (n[0] - '0') * 10 + (n[1] - '0');
// second pair
int second = (n[1] - '0') * 10 + (n[0] - '0');
if (first % 8 == 0)
count++;
if (second % 8 == 0)
count++;
return count;
}
// considering all three-digit sequences
int threeDigit;
for (int i = 0; i < (len - 2); i++) {
threeDigit = (n[i] - '0') * 100 +
(n[i + 1] - '0') * 10 +
(n[i + 2] - '0');
if (threeDigit % 8 == 0)
count++;
}
// Considering the number formed by the
// last digit and the first two digits
threeDigit = (n[len - 1] - '0') * 100 +
(n[0] - '0') * 10 +
(n[1] - '0');
if (threeDigit % 8 == 0)
count++;
// Considering the number formed by the last
// two digits and the first digit
threeDigit = (n[len - 2] - '0') * 100 +
(n[len - 1] - '0') * 10 +
(n[0] - '0');
if (threeDigit % 8 == 0)
count++;
// required count of rotations
return count;
}
// Driver program to test above
int main()
{
string n = "43262488612";
cout << "Rotations: "
<< countRotationsDivBy8(n);
return 0;
}
// Java program to count all
// rotations divisible by 8
import java.io.*;
class GFG
{
// function to count of all
// rotations divisible by 8
static int countRotationsDivBy8(String n)
{
int len = n.length();
int count = 0;
// For single digit number
if (len == 1) {
int oneDigit = n.charAt(0) - '0';
if (oneDigit % 8 == 0)
return 1;
return 0;
}
// For two-digit numbers
// (considering all pairs)
if (len == 2) {
// first pair
int first = (n.charAt(0) - '0') *
10 + (n.charAt(1) - '0');
// second pair
int second = (n.charAt(1) - '0') *
10 + (n.charAt(0) - '0');
if (first % 8 == 0)
count++;
if (second % 8 == 0)
count++;
return count;
}
// considering all three-digit sequences
int threeDigit;
for (int i = 0; i < (len - 2); i++)
{
threeDigit = (n.charAt(i) - '0') * 100 +
(n.charAt(i + 1) - '0') * 10 +
(n.charAt(i + 2) - '0');
if (threeDigit % 8 == 0)
count++;
}
// Considering the number formed by the
// last digit and the first two digits
threeDigit = (n.charAt(len - 1) - '0') * 100 +
(n.charAt(0) - '0') * 10 +
(n.charAt(1) - '0');
if (threeDigit % 8 == 0)
count++;
// Considering the number formed by the last
// two digits and the first digit
threeDigit = (n.charAt(len - 2) - '0') * 100 +
(n.charAt(len - 1) - '0') * 10 +
(n.charAt(0) - '0');
if (threeDigit % 8 == 0)
count++;
// required count of rotations
return count;
}
// Driver program
public static void main (String[] args)
{
String n = "43262488612";
System.out.println( "Rotations: "
+countRotationsDivBy8(n));
}
}
// This code is contributed by vt_m.
# Python3 program to count all
# rotations divisible by 8
# function to count of all
# rotations divisible by 8
def countRotationsDivBy8(n):
l = len(n)
count = 0
# For single digit number
if (l == 1):
oneDigit = int(n[0])
if (oneDigit % 8 == 0):
return 1
return 0
# For two-digit numbers
# (considering all pairs)
if (l == 2):
# first pair
first = int(n[0]) * 10 + int(n[1])
# second pair
second = int(n[1]) * 10 + int(n[0])
if (first % 8 == 0):
count+=1
if (second % 8 == 0):
count+=1
return count
# considering all
# three-digit sequences
threeDigit=0
for i in range(0,(l - 2)):
threeDigit = (int(n[i]) * 100 +
int(n[i + 1]) * 10 +
int(n[i + 2]))
if (threeDigit % 8 == 0):
count+=1
# Considering the number
# formed by the last digit
# and the first two digits
threeDigit = (int(n[l - 1]) * 100 +
int(n[0]) * 10 +
int(n[1]))
if (threeDigit % 8 == 0):
count+=1
# Considering the number
# formed by the last two
# digits and the first digit
threeDigit = (int(n[l - 2]) * 100 +
int(n[l - 1]) * 10 +
int(n[0]))
if (threeDigit % 8 == 0):
count+=1
# required count
# of rotations
return count
# Driver Code
if __name__=='__main__':
n = "43262488612"
print("Rotations:",countRotationsDivBy8(n))
# This code is contributed by mits.
// C# program to count all
// rotations divisible by 8
using System;
class GFG {
// function to count of all
// rotations divisible by 8
static int countRotationsDivBy8(String n)
{
int len = n.Length;
int count = 0;
// For single digit number
if (len == 1)
{
int oneDigit = n[0] - '0';
if (oneDigit % 8 == 0)
return 1;
return 0;
}
// For two-digit numbers
// (considering all pairs)
if (len == 2)
{
// first pair
int first = (n[0] - '0') *
10 + (n[1] - '0');
// second pair
int second = (n[1] - '0') *
10 + (n[0] - '0');
if (first % 8 == 0)
count++;
if (second % 8 == 0)
count++;
return count;
}
// considering all three -
// digit sequences
int threeDigit;
for (int i = 0; i < (len - 2); i++)
{
threeDigit = (n[i] - '0') * 100 +
(n[i + 1] - '0') * 10 +
(n[i + 2] - '0');
if (threeDigit % 8 == 0)
count++;
}
// Considering the number formed by the
// last digit and the first two digits
threeDigit = (n[len - 1] - '0') * 100 +
(n[0] - '0') * 10 +
(n[1] - '0');
if (threeDigit % 8 == 0)
count++;
// Considering the number formed
// by the last two digits and
// the first digit
threeDigit = (n[len - 2] - '0') * 100 +
(n[len - 1] - '0') * 10 +
(n[0] - '0');
if (threeDigit % 8 == 0)
count++;
// required count of rotations
return count;
}
// Driver Code
public static void Main ()
{
String n = "43262488612";
Console.Write("Rotations: "
+countRotationsDivBy8(n));
}
}
// This code is contributed by Nitin Mittal.
<?php
// PHP program to count all
// rotations divisible by 8
// function to count of all
// rotations divisible by 8
function countRotationsDivBy8($n)
{
$len = strlen($n);
$count = 0;
// For single digit number
if ($len == 1)
{
$oneDigit = $n[0] - '0';
if ($oneDigit % 8 == 0)
return 1;
return 0;
}
// For two-digit numbers
// (considering all pairs)
if ($len == 2)
{
// first pair
$first = ($n[0] - '0') * 10 +
($n[1] - '0');
// second pair
$second = ($n[1] - '0') * 10 +
($n[0] - '0');
if ($first % 8 == 0)
$count++;
if ($second % 8 == 0)
$count++;
return $count;
}
// considering all
// three-digit sequences
$threeDigit;
for ($i = 0; $i < ($len - 2); $i++)
{
$threeDigit = ($n[$i] - '0') * 100 +
($n[$i + 1] - '0') * 10 +
($n[$i + 2] - '0');
if ($threeDigit % 8 == 0)
$count++;
}
// Considering the number
// formed by the last digit
// and the first two digits
$threeDigit = ($n[$len - 1] - '0') * 100 +
($n[0] - '0') * 10 +
($n[1] - '0');
if ($threeDigit % 8 == 0)
$count++;
// Considering the number
// formed by the last two
// digits and the first digit
$threeDigit = ($n[$len - 2] - '0') * 100 +
($n[$len - 1] - '0') * 10 +
($n[0] - '0');
if ($threeDigit % 8 == 0)
$count++;
// required count
// of rotations
return $count;
}
// Driver Code
$n = "43262488612";
echo "Rotations: " .
countRotationsDivBy8($n);
// This code is contributed by mits.
?>
<script>
// Javascript program to count all
// rotations divisible by 8
// Function to count of all
// rotations divisible by 8
function countRotationsDivBy8(n)
{
let len = n.length;
let count = 0;
// For single digit number
if (len == 1)
{
let oneDigit = n[0] - '0';
if (oneDigit % 8 == 0)
return 1;
return 0;
}
// For two-digit numbers
// (considering all pairs)
if (len == 2)
{
// first pair
let first = (n[0] - '0') * 10 +
(n[1] - '0');
// second pair
let second = (n[1] - '0') * 10 +
(n[0] - '0');
if (first % 8 == 0)
count++;
if (second % 8 == 0)
count++;
return count;
}
// Considering all
// three-digit sequences
let threeDigit;
for(let i = 0; i < (len - 2); i++)
{
threeDigit = (n[i] - '0') * 100 +
(n[i + 1] - '0') * 10 +
(n[i + 2] - '0');
if (threeDigit % 8 == 0)
count++;
}
// Considering the number
// formed by the last digit
// and the first two digits
threeDigit = (n[len - 1] - '0') * 100 +
(n[0] - '0') * 10 +
(n[1] - '0');
if (threeDigit % 8 == 0)
count++;
// Considering the number
// formed by the last two
// digits and the first digit
threeDigit = (n[len - 2] - '0') * 100 +
(n[len - 1] - '0') * 10 +
(n[0] - '0');
if (threeDigit % 8 == 0)
count++;
// Required count
// of rotations
return count;
}
// Driver Code
let n = "43262488612";
document.write("Rotations: " +
countRotationsDivBy8(n));
// This code is contributed by _saurabh_jaiswal
</script>
Output:
Rotations: 4
Time Complexity : O(n), where n is the number of digits in input number.
Auxiliary Space: O(1)
Similar Reads
Count rotations divisible by 4 Given a large positive number as string, count all rotations of the given number which are divisible by 4. Examples: Input: 8 Output: 1 Input: 20 Output: 1 Rotation: 20 is divisible by 4 02 is not divisible by 4 Input : 13502 Output : 0 No rotation is divisible by 4 Input : 43292816 Output : 5 5 rot
6 min read
Javascript Program to Count rotations divisible by 8 Given a large positive number as string, count all rotations of the given number which are divisible by 8.Examples: Input: 8Output: 1Input: 40Output: 1Rotation: 40 is divisible by 8 04 is not divisible by 8Input : 13502Output : 0No rotation is divisible by 8Input : 43262488612Output : 4Approach: It
3 min read
Javascript Program to Count rotations divisible by 4 Given a large positive number as string, count all rotations of the given number which are divisible by 4. Examples: Input: 8Output: 1Input: 20Output: 1Rotation: 20 is divisible by 4 02 is not divisible by 4Input : 13502Output : 0No rotation is divisible by 4Input : 43292816Output : 55 rotations are
2 min read
Count divisible pairs in an array Given an array, count pairs in the array such that one element of the pair divides the other. Examples: Input : arr[] = {1, 2, 3} Output : 2 The two pairs are (1, 2) and (1, 3) Input : arr[] = {2, 3, 5, 7} Output: 0 Naive Approach: The brute force approach can be implemented by iterating through eve
10 min read
Count pairs in array whose sum is divisible by 4 Given a array if 'n' positive integers. Count number of pairs of integers in the array that have the sum divisible by 4. Examples : Input: {2, 2, 1, 7, 5}Output: 3Explanation:Only three pairs are possible whose sumis divisible by '4' i.e., (2, 2), (1, 7) and (7, 5)Input: {2, 2, 3, 5, 6}Output: 4Reco
9 min read
Count pairs in array whose sum is divisible by K Given an array A[] and positive integer K, the task is to count the total number of pairs in the array whose sum is divisible by K. Note: This question is a generalized version of this Examples: Input : A[] = {2, 2, 1, 7, 5, 3}, K = 4 Output : 5 Explanation : There are five pairs possible whose sum
10 min read