Updates

Author: mrjbq7

rosetta-code/solutions/100-doors.factor

@@ -22,6 +22,15 @@
 ! Opening only those doors is an optimization that may also be expressed;
 ! however, as should be obvious, this defeats the intent of comparing
 ! implementations across programming languages.
+! 
+! Why doesn't syntax highlighting work on this page ?:
+! 
+! Currently, there is a limit on how many <syntaxhighlight> tags can
+! appear on a page, so only the first few languages get highlighting, the
+! rest are shown in monochrome.
+! You could try "manual highlighting", possibly using one of the
+! highlighters on Syntax highlighting using Mediawiki formatting or
+! something similar.
 
 USING: bit-arrays formatting fry kernel math math.ranges
 sequences ;

rosetta-code/solutions/abc-correlation.factor

@@ -2,9 +2,9 @@
 ! 
 ! Task:
 ! 
-! Get a string/input and store it into a variable or something and compare
-! the amount of "a", "b" and "c" . Other characters like "r", "h" or "5"
-! MUST be ignored. If the amount of "a"'s, "b"'s and "c"'s are equal
-! return true. Otherwise return false
+! Get a string input and store it into a variable or something and compare
+! the number of occurrences of the letters "a", "b" and "c". All other
+! characters MUST be ignored. If the "a"'s, "b"'s and "c"'s occur with
+! exactly equal frequency, return true; otherwise return false.
 
 

rosetta-code/solutions/append-numbers-at-same-position-in-strings.factor

@@ -8,7 +8,7 @@
 ! 
 ! list3 = [19,20,21,22,23,24,25,26,27]
 ! 
-! Turn the numbers them into strings and concatenate them.
+! At each index, turn the numbers into strings and concatenate them.
 ! 
 ! The result should be:
 ! 

rosetta-code/solutions/brilliant-numbers.factor

@@ -27,6 +27,7 @@
 ! 
 ! See also
 ! * Numbers Aplenty - Brilliant numbers
+! * - Like the task upper Limit 1E201
 ! * OEIS:A078972 - Brilliant numbers: semiprimes whose prime factors have the same number of decimal digits
 
 USING: assocs formatting grouping io kernel lists lists.lazy

rosetta-code/solutions/brzozowski-algebraic-method.factor

@@ -0,0 +1,45 @@
+! Description
+! 
+! The Brzozowski Algebraic Method is a technique used in automata theory,
+! specifically for constructing the minimal deterministic finite automaton
+! (DFA) from a given nondeterministic finite automaton (NFA). It was
+! introduced by Janusz Brzozowski in 1962 and involves the use of
+! algebraic transformations to simplify and optimize automata.
+! 
+! As the workings of the algorithm are clearly described in the linked
+! article they will not be repeated here.
+! 
+! Task:
+! 
+! Implement the Brzozowski Algebraic Method to convert an NFA
+! representation into a regular expression. The implementation should:
+! 
+! 1. Take as input:
+! 
+!   - A 2D array 'a' representing the transition matrix of the NFA
+!   - An array 'b' representing the final states
+! 
+! 2. Include functionality to:
+! 
+!   - Handle basic regular expression operations (Empty, Epsilon, Character, Union, Concatenation, Star)
+!   - Print regular expressions in a readable format
+!   - Simplify regular expressions using algebraic rules
+! 
+! 3. Apply the Brzozowski algorithm to:
+! 
+!   - Process the transition matrix in reverse order
+!   - Update transitions using Star and Concatenation operations
+!   - Combine paths using Union operations
+!   - Generate a final regular expression representing the language accepted by the NFA
+! 
+! 4. Include simplification rules for:
+! 
+!   - Eliminating redundant unions (e + e → e)
+!   - Handling identity elements (e·1 → e, 1·e → e)
+!   - Handling zero elements (e·0 → 0, 0·e → 0)
+!   - Simplifying star operations (0* → 1, 1* → 1)
+! 
+! The implementation should be able to process the given example input and
+! produce both the raw and simplified regular expressions as output.
+
+

rosetta-code/solutions/csv-data-manipulation.factor

@@ -26,5 +26,9 @@
 ! 
 ! If possible, illustrate the use of built-in or standard functions,
 ! methods, or libraries, that handle generic CSV files.
+! 
+! Related tasks:
+! 
+! -   Convert_CSV_records_to_TSV
 
 

rosetta-code/solutions/cumulative-standard-deviation.factor

@@ -1,3 +1,5 @@
+! Task
+! 
 ! Write a stateful function, class, generator or co-routine that takes a
 ! series of floating point numbers, one at a time, and returns the running
 ! standard deviation of the series.

rosetta-code/solutions/exactly-three-adjacent-3-in-lists.factor

@@ -13,6 +13,8 @@
 ! list[5] = [4,6,8,7,2,3,3,3,1]
 ! 
 ! For each list, print 'true' if the list contains exactly three '3's that
-! form a consecutive subsequence, otherwise print 'false'.
+! form a consecutive subsequence, otherwise print 'false'. That is, print
+! false unless there is exactly one run of three '3's and there is no
+! other occurrence of a '3'.
 
 

rosetta-code/solutions/harriss-spiral.factor

@@ -0,0 +1,41 @@
+! The discovery of the Harriss Spiral was first publicized about 2015. It
+! is the brainchild of Edmund Orme Harriss, a British mathematician,
+! writer and artist. Since 2010 he has been at the Fulbright College of
+! Arts & Sciences at The University of Arkansas in Fayetteville, Arkansas,
+! where he is an Assistant Professor of Arts & Sciences (ARSC) and
+! Mathematical Sciences (MASC). He does research in the Geometry of
+! Tilings and Patterns,a branch of Convex and Discrete Geometry.
+! 
+! In Harriss' own words, his namesake spiral, "…is constructed by taking a
+! rectangle with height 1 and length the real root of x^3-x-1=0. With this
+! rectangle you can cut off a similar rectangle, and then a square to get
+! another similar rectangle. You can repeat this construction on the
+! smaller similar rectangles, in each case getting a square and two more
+! similar rectangles. Now simply adding an arc of a circle to each square
+! (in the right way) gives the spiral, or more correctly the nest of
+! spirals." [Fractal spiral discovered by Edmund Harriss]
+! 
+! The Harriss Spiral is a variant of the decomposition for the golden
+! spiral in which a rectangle is decomposed into three smaller units: a
+! rectangle similar to the original rotated 90◦, a square, and a similar
+! rectangle in the same orientation as the original rectangle. As in the
+! golden-spiral decomposition, the individual non-square units can be
+! decomposed further along these lines to create a cascading filling of
+! the rectangle with ever-smaller squares. Unlike in the golden spiral,
+! each square is incident on two smaller regions appearing in the same
+! generation; if arcs are drawn between each square and the square which
+! appeared in its previous generation The result is a branching structure,
+! shown at right.
+! 
+! As with the golden spiral decomposition, the Harriss spiral requires a
+! specific aspect ratio for the original rectangle. While the golden
+! spiral requires an aspect ratio which is a solution to 𝜙2 = 𝜙 + 1 — the
+! Golden Ratio of 1:1.618 — the Harriss spiral requires an aspect ratio 𝜌
+! satisfying 𝜌3 = 𝜌 + 1, whose real solution is known as the plastic ratio
+! and equals 1:1.3247.
+! 
+! Task:
+! 
+! Create and display a Harriss Spiral in your language.
+
+

rosetta-code/solutions/hash-join.factor

@@ -3,12 +3,16 @@
 ! this operation is the nested loop join algorithm, but a more scalable
 ! alternative is the hash join algorithm.
 ! 
+! Task
+! 
 ! Implement the "hash join" algorithm, and demonstrate that it passes the
 ! test-case listed below.
 ! 
 ! You should represent the tables as data structures that feel natural in
 ! your programming language.
 ! 
+! Guidance
+! 
 ! The "hash join" algorithm consists of two steps:
 ! 
 ! 1.  Hash phase: Create a multimap from one of the two tables, mapping
@@ -41,6 +45,8 @@
 !       let c = the concatenation of row a and row b
 !       place row c in table C
 ! 
+! Test case
+! 
 ! +----------------------------------+----------------------------------+
 ! | Input                            | Output                           |
 ! +==================================+==================================+

rosetta-code/solutions/hierholzer-s-algorithm.factor

@@ -0,0 +1,64 @@
+! Description
+! 
+! Hierholzer's Algorithm is an efficient way to find Eulerian circuits in
+! a graph.
+! 
+!     Algorithm: Hierholzer's Algorithm
+!     Input: Graph G = (V, E) represented as adjacency list
+!     Output: Eulerian circuit as ordered list of vertices
+! 
+!     Function FindEulerianCircuit(Graph G):
+!         // Initialize empty circuit and stack
+!         Circuit = empty list
+!         Stack = empty stack
+! 
+!         // Start from any vertex with non-zero degree
+!         current = any vertex v in V where degree(v) > 0
+!         Push current to Stack
+! 
+!         While Stack is not empty:
+!             if OutDegree(current) == 0:
+!                 // Add to circuit when no more unused edges
+!                 Add current to front of Circuit
+!                 current = Pop from Stack
+!             else:
+!                 // Follow an unused edge
+!                 Push current to Stack
+!                 next = any adjacent vertex with unused edge from current
+!                 Remove edge (current, next) from G
+!                 current = next
+! 
+!         Return Circuit
+! 
+!     Function VerifyEulerianCircuit(Graph G):
+!         For each vertex v in G:
+!             If InDegree(v) ≠ OutDegree(v):
+!                 Return false
+!         If Graph is not strongly connected:
+!             Return false
+!         Return true
+! 
+!     Main Algorithm:
+!         1. If not VerifyEulerianCircuit(G):
+!             Return "No Eulerian circuit exists"
+! 
+!         2. Circuit = FindEulerianCircuit(G)
+! 
+!         3. If Circuit contains all edges:
+!             Return Circuit
+!         Else:
+!             Return "No Eulerian circuit exists"
+! 
+!     Preconditions:
+!         - Graph must be connected
+!         - All vertices must have equal in-degree and out-degree
+! 
+!     Time Complexity: O(|E|) where E is the number of edges
+!     Space Complexity: O(|V|) where V is the number of vertices
+! 
+! Task
+! 
+! Implement the Hierholze's Algorithm in your language and test it using
+! the same examples as in the OCaml entry.
+
+

rosetta-code/solutions/mcnaughton-yamada-thompson-algorithm.factor

@@ -0,0 +1,62 @@
+! Description
+! 
+! [http://cgosorio.es/Seshat/thompson?expr=a.(a%7Cb.a)*%7Cc*.a The
+! McNaughton-Yamada-Thompson algorithm] (aka. Thompson algorithm) is
+! designed to transform a regular expression into a Non-Deterministic
+! Finite Automaton (NDFA) that recognizes the language represented by the
+! regular expression.
+! 
+! As the workings of the algorithm are clearly described in the linked
+! article they will not be repeated here.
+! 
+! Task:
+! 
+! Implement Thompson's Construction Algorithm to convert regular
+! expressions into NFAs and match strings. The implementation should:
+! 
+! 1. Support the following operations:
+! 
+!   - Concatenation (.)
+!   - Union/Alternation (|)
+!   - Kleene Star (*)
+!   - Plus (+)
+!   - Optional (?)
+!   - Basic character literals
+! 
+! 2. Include the following components:
+! 
+!   - A regex-to-postfix converter using Shunting Yard algorithm
+!   - NFA state and transition representation
+!   - Epsilon closure computation
+!   - Pattern matching functionality
+! 
+! 3. Implement the following features:
+! 
+!   - State structure with:
+!     * Character label
+!     * Two possible transitions (edge1, edge2)
+!     * Support for epsilon transitions
+! 
+!   - NFA structure containing:
+!     * Initial state pointer
+!     * Accept state pointer
+! 
+!   - String matching that:
+!     * Follows epsilon transitions
+!     * Tracks current possible states
+!     * Processes input characters
+!     * Determines if final state is accepting
+! 
+! 4. Handle test cases demonstrating:
+! 
+!   - Basic concatenation (a.b.c)
+!   - Star operations (c*)
+!   - Alternation (b|d)
+!   - Complex combinations ((a.(b|d))*)
+!   - Empty strings and various input patterns
+! 
+! The implementation should efficiently construct NFAs from regular
+! expressions and correctly determine whether input strings match the
+! given patterns.
+
+

rosetta-code/solutions/pollard-s-rho-algorithm.factor

@@ -0,0 +1,49 @@
+! In the area of number decomposition algorithms, Pollard's rho algorithm
+! is a fast, yet fairly simple method to find factors of a number, using a
+! pseudorandom number generator modulo the number.
+! 
+! Except for trivial factors like 2, 3, 5 etc., it is much faster than
+! trial division, finding a factor quite often, but may terminate without
+! a factor. Thus it cannot prove that a number is prime. If it is known
+! that a number is not prime, the algorithm can be re-iterated with
+! changed parameters to finally find a factor (not necessarily a prime
+! factor) with quite high probability.
+! 
+! Task:
+! 
+! Write a function to demonstrate the algorithm (see pseudocode in
+! Wikipedia). The intent is to show the principle as clear as possible in
+! the respective language, but avoid an endless loop. Enhanced versions
+! may be presented as extra examples.
+! 
+! Warning:
+! 
+! The variables 'x' and 'y' may be equal during an iteration, calling
+! 'gcd()' with first argument 0, while the GCD is only defined for
+! postitive numbers, so a library gdc() function might fail. If in this
+! case, the other argument is returned, the algorithm reports failure,
+! which is acceptable. The gcd() functions supplied for AWK and C have
+! this property.
+! 
+! Example numbers, if supported:
+! 
+! -   4294967213 = 75167 * 57139 (32 bits)
+! -   9759463979 = 98779 * 98801 (34 bits)
+! -   34225158206557151 = 130051349 * 263166499 (55 bits)
+! -   763218146048580636353 = 25998278833 * 29356487441 (70 bits)
+! 
+! Related tasks:
+! 
+! -   prime decomposition
+! -   AKS test for primes
+! -   factors of an integer
+! -   factors of a Mersenne number
+! -   trial factoring of a Mersenne number
+! -   partition an integer X into N primes
+! -   sequence of primes by Trial Division
+! 
+! References:
+! 
+! -   Wikipedia: Pollard's rho algorithm
+
+