rxjava solution - check only row 1

src/main/java/reactivestreams/Solution.java

@@ -2,12 +2,11 @@ package reactivestreams;
 
 import java.util.Scanner;
 import java.util.Spliterator;
-import java.util.concurrent.SubmissionPublisher;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
 /**
- * stream.Solution involving a Sukdoku stream.Board, a stream.SudokuVerifier, plus some ReactiveStreams processing.
+ * stream.Solution involving a Sukdoku Board, a SudokuVerifier, plus some ReactiveStreams processing.
 **/
 class Solution {
 	

src/main/java/rxjava/Solution.java

@@ -0,0 +1,23 @@
+package rxjava;
+
+import java.util.Scanner;
+import java.util.Spliterator;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/**
+ * stream.Solution involving a Sukdoku Board, a SudokuVerifier, plus some RxJava processing.
+**/
+class Solution {
+	
+	public static void main( String[] args ) {
+		// Setup stream on System.in
+		Scanner in = new Scanner( System.in );
+		Spliterator spliterator = ((Iterable) () -> in).spliterator();
+		Stream<String> digitStream = StreamSupport.stream(spliterator, false);
+		// Setup SudokuVerifier
+		SudokuVerifier verifier = new SudokuVerifier(digitStream);
+		// Verify and print out result
+		System.out.println(verifier.isSolved());
+	}
+}

src/main/java/rxjava/SudokuVerifier.java

@@ -0,0 +1,55 @@
+package rxjava;
+
+import io.reactivex.rxjava3.annotations.NonNull;
+import io.reactivex.rxjava3.core.Observable;
+import io.reactivex.rxjava3.core.Single;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+
+public class SudokuVerifier {
+
+	@NonNull Observable<String> digitObservable;
+
+	public SudokuVerifier(Stream<String> digitStream) {
+		// Observable on the digit stream
+		digitObservable = Observable.fromStream(digitStream);
+	}
+
+	public boolean isSolved() {
+		AtomicInteger row = new AtomicInteger(1);
+		AtomicInteger column = new AtomicInteger(0);
+		@NonNull Observable<DigitField> digitFieldObservable = digitObservable
+			.map(digit -> digitField(row, column, digit));
+		@NonNull Observable<DigitField> filter = digitFieldObservable
+			.filter(digitField -> digitField.row == 1);
+		return isSolved(filter).blockingGet();
+	}
+
+	@NonNull Single<Boolean> isSolved(@NonNull Observable<DigitField> filter) {
+		return filter
+			.map(digitField -> digitField.digit)
+			.distinct().count()
+			.map(count -> count == 9);
+	}
+
+	DigitField digitField(AtomicInteger row, AtomicInteger column, String digit) {
+		if (column.getAndIncrement() > 9) {
+			row.getAndIncrement();
+			column.set(1);
+		}
+		return new DigitField(row.get(), column.get(), digit);
+	}
+
+	static class DigitField {
+		int row;
+		int column;
+		String digit;
+
+		public DigitField(int row, int column, String digit) {
+			this.row = row;
+			this.column = column;
+			this.digit = digit;
+		}
+	}
+}

src/main/java/stream/Solution.java

@@ -7,7 +7,7 @@ import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
 /**
- * stream.Solution involving a Sukdoku stream.Board, a stream.SudokuVerifier, plus some Stream processing.
+ * stream.Solution involving a Sukdoku Board, a SudokuVerifier, plus some Stream processing.
 **/
 class Solution {