Data update

Task/First-class-environments/C++/first-class-environments.cpp

@@ -0,0 +1,69 @@
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+class Environment {
+public:
+    Environment(const uint32_t& aSequence, const uint32_t& aCount) : sequence(aSequence), count(aCount) { }
+
+    uint32_t sequence, count;
+};
+
+const uint32_t JOBS(12);
+uint32_t sequence, count, current_id;
+std::vector<Environment> environments = { Environment(1, 0), Environment(2, 0),  Environment(3, 0),
+	Environment(4, 0), Environment(5, 0), Environment(6, 0),  Environment(7, 0), Environment(8, 0),
+	Environment(9, 0), Environment(10, 0),  Environment(11, 0), Environment(12, 0) };
+
+void switch_to(const uint32_t& id) {
+	if ( id != current_id ) {
+		environments[current_id].sequence = sequence;
+		environments[current_id].count = count;
+		current_id = id;
+	}
+
+	sequence = environments[id].sequence;
+	count = environments[id].count;
+}
+
+void hailstone() {
+	std::cout << std::setw(4) << sequence;
+	if ( sequence == 1 ) {
+		return;
+	}
+
+	count += 1;
+	sequence = ( sequence % 2 == 1 ) ? 3 * sequence + 1 : sequence / 2;
+}
+
+bool all_done() {
+	for ( uint32_t job = 0; job < JOBS; ++job ) {
+		switch_to(job);
+		if ( sequence > 1 ) {
+			return false;
+		}
+	}
+	return true;
+}
+
+void code() {
+	 while ( ! all_done() ) {
+		for ( uint32_t job = 0; job < JOBS; ++job ) {
+			switch_to(job);
+			hailstone();
+		}
+		std::cout << "\n";
+	}
+
+	std::cout << "\n" << "Counts:" << "\n";
+	for ( uint32_t job = 0; job < JOBS; ++job ) {
+		switch_to(job);
+		std::cout << std::setw(4) << count;
+	}
+	std::cout << "\n";
+}
+
+int main() {
+	code();
+}

Task/First-class-environments/Java/first-class-environments.java

@@ -1,21 +1,20 @@
 import java.util.List;
-import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public final class FirstClassEnvironments {
 
-	public static void main(String[] aArgs) {
+	public static void main(String[] args) {
 		code();
 	}
 	
 	private static void code() {
-		do {
+		while ( ! allDone() ) {
 	        for ( int job = 0; job < JOBS; job++ ) {
 	            switchTo(job);
 	            hailstone();
 	        }
 	        System.out.println();	
-	    } while ( ! allDone() );
+	    }
 
 	    System.out.println(System.lineSeparator() + "Counts:");
 	    for ( int job = 0; job < JOBS; job++ ) {
@@ -45,30 +44,30 @@ public final class FirstClassEnvironments {
 	    sequence = ( sequence % 2 == 1 ) ? 3 * sequence + 1 : sequence / 2;
 	}
 	
-	private static void switchTo(int aID) {
-	    if ( aID != currentId ) {
-	        environments.get(currentId).seq = sequence;
+	private static void switchTo(int id) {
+	    if ( id != currentId ) {
+	        environments.get(currentId).sequence = sequence;
 	        environments.get(currentId).count = count;
-	        currentId = aID;
+	        currentId = id;
 	    }
 	
-	    sequence = environments.get(aID).seq;
-	    count = environments.get(aID).count;
+	    sequence = environments.get(id).sequence;
+	    count = environments.get(id).count;
 	}	
 	
 	private static class Environment {
 		
-		public Environment(int aSeq, int aCount) {
-			seq = aSeq; count = aCount;
+		public Environment(int aSequence, int aCount) {
+			sequence = aSequence; count = aCount;
 		}
 		
-		private int seq, count;
+		private int sequence, count;
 		
 	}
 	
 	private static int sequence, count, currentId;	
 	private static List<Environment> environments =
-		IntStream.rangeClosed(1, 12).mapToObj( i -> new Environment(i, 0 ) ).collect(Collectors.toList());
+		IntStream.rangeClosed(1, 12).mapToObj( i -> new Environment(i, 0) ).toList();
 	
 	private static final int JOBS = 12;