# Java Program for 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: 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 Itsrotationsare 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.

## Java

`// 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.` |

**Output:**

Rotations: 4

**Time Complexity :** O(n), where **n** is the number of digits in input number.

Please refer complete article on Count rotations divisible by 8 for more details!