quick and dirty solution using for loops over arrays and bitset

src/main/java/Solution.java

@@ -1,59 +1,71 @@
 import java.util.*;
-import java.util.function.IntFunction;
-import java.util.stream.*;
 
+/**
+ * Template code to help you parse the standard input 
+ * according to the problem statement.
+ **/
 class Solution {
 	
-	private static final int SIZE = 9;
-	private static final int BLOCK_SIZE = 3;
-	
 	public static void main( String[] args ) {
-		var digits = new Scanner( System.in ).tokens()
+		Scanner in = new Scanner( System.in );
-				.map( Integer::valueOf )
-				.collect( Collectors.toList() );
 		
-		System.out.println( checkSudoku( digits ));
+		int[][] grid = new int[9][9];
+		for ( int index = 0; in.hasNext(); index++ ) {
+			int row = index / 9;
+			int col = index % 9;
+			grid[row][col] = in.nextShort();
 		}
 		
-	/**
+		System.out.println( checkHorizontally( grid )
-	 * The basic idea is to split the digits into groups that can be verified by the same logic over and over again.
+		                    && checkVertically( grid )
-	 * The code will create 27 groups - 9 lines, 9 rows and 9 blocks - and checks for all digits in each group.
+		                    && checkAllBlocks( grid )
-	 */
+		);
-	private static boolean checkSudoku( List<Integer> digits ) {
-		return Stream.of(
-				filterGroup( digits, Solution::byLine ),
-				filterGroup( digits, Solution::byRow ),
-				filterGroup( digits, Solution::byBlock )
-		).flatMap( Collection::stream )
-		 .allMatch( Solution::checkAllDigits );
 	}
 	
-	/**
+	private static boolean checkHorizontally( int[][] grid ) {
-	 * Splitting is done with a grouping function that calculates the group number for a grid index.
+		//noinspection ForLoopReplaceableByForEach
-	 */
+		for ( int r = 0; r < grid.length; r++ ) {
-	private static Collection<List<Integer>> filterGroup( List<Integer> digits, IntFunction<Integer> grpFunc ) {
+			BitSet bs = new BitSet( 9 );
-		var group = IntStream.range( 0, digits.size() ).boxed()
+			for ( int c = 0; c < grid[r].length; c++ ) {
-				.collect( Collectors.groupingBy( grpFunc::apply, Collectors.mapping( digits::get, Collectors.toList() )));
+				bs.set( grid[r][c] );
-		return group.values();
 			}
-	
+			if ( bs.cardinality() != 9 ) return false;
-	/** 
+		}
-	 * Checks if every digit from 1 to 9 is present in each group.
+		return true;
-	 */
-	private static boolean checkAllDigits( List<Integer> group ) {
-		return group.stream().distinct().count() == SIZE;
 	}
 	
-	private static int byLine( int index ) {
+	private static boolean checkVertically( int[][] grid ) {
-		return index / SIZE;
+		for ( int c = 0; c < 9; c++ ) {
+			BitSet bs = new BitSet( 9 );
+			//noinspection ForLoopReplaceableByForEach
+			for ( int r = 0; r < grid.length; r++ ) {
+				bs.set( grid[r][c] );
+			}
+			if ( bs.cardinality() != 9 ) return false;
+		}
+		return true;
 	}
 	
-	private static int byRow( int index ) {
+	private static boolean checkAllBlocks( int[][] grid ) {
-		return index % SIZE;
+		return checkBlock( grid, 0, 0 )
+		       && checkBlock( grid, 0, 3 )
+		       && checkBlock( grid, 0, 6 )
+		       && checkBlock( grid, 3, 0 )
+		       && checkBlock( grid, 3, 3 )
+		       && checkBlock( grid, 3, 6 )
+		       && checkBlock( grid, 6, 0 )
+		       && checkBlock( grid, 6, 3 )
+		       && checkBlock( grid, 6, 6 );
 	}
 	
-	private static int byBlock( int index ) {
+	private static boolean checkBlock( int[][] block, int indexTop, int indexLeft ) {
-		return byRow( index ) / BLOCK_SIZE + ( index / ( SIZE * BLOCK_SIZE )) * BLOCK_SIZE;
+		BitSet bs = new BitSet( 9 );
+		for ( int r = indexTop; r < indexTop + 3; r++ ) {
+			for ( int c = indexLeft; c < indexLeft + 3; c++ ) {
+				bs.set( block[r][c] );
+			}
+		}
+		return ( bs.cardinality() == 9 );
 	}
 	
 }