pharaouk/rosetta-code · Datasets at Hugging Face

task_url stringlengths 30 116	task_name stringlengths 2 86	task_description stringlengths 0 14.4k	language_url stringlengths 2 53	language_name stringlengths 1 52	code stringlengths 0 61.9k
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#JSON	JSON	{"x":1,"y":2}
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Julia	Julia	struct Point{T<:Real} x::T y::T end
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#RLaB	RLaB	>> s1 = "A string" A string >> s2 = s1 A string
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Robotic	Robotic	set "$string1" to "This is a string" set "$string2" to "$string1" * "&$string2&"
http://rosettacode.org/wiki/Constrained_random_points_on_a_circle	Constrained random points on a circle	Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.	#PicoLisp	PicoLisp	(let Area (make (do 31 (link (need 31 " ")))) (use (X Y) (do 100 (until (>= 15 (sqrt (+ (* (setq X (rand -15 15)) X) (* (setq Y (rand -15 15)) Y) ) ) 10 ) ) (set (nth Area (+ 16 X) (+ 16 Y)) "#") ) ) (mapc prinl Area) )
http://rosettacode.org/wiki/Convex_hull	Convex hull	Find the points which form a convex hull from a set of arbitrary two dimensional points. For example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15). See also Convex Hull (youtube) http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/	#Tcl	Tcl	catch {namespace delete test_convex_hull} ;# Start with a clean namespace namespace eval test_convex_hull { package require Tcl 8.5 ;# maybe earlier? interp alias {} @ {} lindex;# An essential readability helper for list indexing proc cross {o a b} { ### 2D cross product of OA and OB vectors ### return [expr {([@ $a 0] - [@ $o 0]) * ([@ $b 1] - [@ $o 1]) - ([@ $a 1] - [@ $o 1]) * ([@ $b 0] - [@ $o 0]) }] } proc calc_hull_edge {points} { ### Build up hull edge ### set edge [list] foreach p $points { while {[llength $edge ] >= 2 && [cross [@ $edge end-1] [@ $edge end] $p] <= 0} { set edge [lreplace $edge end end] ;# pop } lappend edge $p } return $edge } proc convex_hull {points} { ### Convex hull of a set of 2D points ### # Unique points set points [lsort -unique $points] # Sorted points set points [lsort -real -index 0 [lsort -real -index 1 $points]] # No calculation necessary if {[llength $points] <= 1} { return $points } set lower [calc_hull_edge $points] set upper [calc_hull_edge [lreverse $points]] return [concat [lrange $lower 0 end-1] [lrange $upper 0 end-1]] } # Testing set tpoints {{16 3} {12 17} {0 6} {-4 -6} {16 6} {16 -7} {16 -3} {17 -4} {5 19} {19 -8} {3 16} {12 13} {3 -4} {17 5} {-3 15} {-3 -9} {0 11} {-9 -3} {-4 -2} {12 10}} puts "Test points:" puts [lrange $tpoints 0 end] ;# prettier puts "Convex Hull:" puts [convex_hull $tpoints] }
http://rosettacode.org/wiki/Convert_seconds_to_compound_duration	Convert seconds to compound duration	Task Write a function or program which: takes a positive integer representing a duration in seconds as input (e.g., 100), and returns a string which shows the same duration decomposed into: weeks, days, hours, minutes, and seconds. This is detailed below (e.g., "2 hr, 59 sec"). Demonstrate that it passes the following three test-cases: Test Cases input number output string 7259 2 hr, 59 sec 86400 1 d 6000000 9 wk, 6 d, 10 hr, 40 min Details The following five units should be used: unit suffix used in output conversion week wk 1 week = 7 days day d 1 day = 24 hours hour hr 1 hour = 60 minutes minute min 1 minute = 60 seconds second sec However, only include quantities with non-zero values in the output (e.g., return "1 d" and not "0 wk, 1 d, 0 hr, 0 min, 0 sec"). Give larger units precedence over smaller ones as much as possible (e.g., return 2 min, 10 sec and not 1 min, 70 sec or 130 sec) Mimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).	#XPL0	XPL0	char Str(80); func Duration(Sec); \Convert seconds to compound duration int Sec, Amt, Unit, DoComma, I, Quot; [Amt:= [7246060, 246060, 6060, 60, 1]; Unit:= [" wk", " d", " hr", " min", " sec"]; DoComma:= false; for I:= 0 to 4 do [Quot:= Sec/Amt(I); Sec:= rem(0); if Quot # 0 then [if DoComma then Text(8, ", "); DoComma:= true; IntOut(8, Quot); Text(8, Unit(I)); ]; ]; ChOut(8, $0D); ChOut(8, $8A); \terminating CR+LF I:= 0; loop [Str(I):= ChIn(8); if Str(I) >= $80 then return Str; I:= I+1; ]; ]; [Text(0, Duration(7259)); Text(0, Duration(86400)); Text(0, Duration(6_000_000)); ]
http://rosettacode.org/wiki/Convert_seconds_to_compound_duration	Convert seconds to compound duration	Task Write a function or program which: takes a positive integer representing a duration in seconds as input (e.g., 100), and returns a string which shows the same duration decomposed into: weeks, days, hours, minutes, and seconds. This is detailed below (e.g., "2 hr, 59 sec"). Demonstrate that it passes the following three test-cases: Test Cases input number output string 7259 2 hr, 59 sec 86400 1 d 6000000 9 wk, 6 d, 10 hr, 40 min Details The following five units should be used: unit suffix used in output conversion week wk 1 week = 7 days day d 1 day = 24 hours hour hr 1 hour = 60 minutes minute min 1 minute = 60 seconds second sec However, only include quantities with non-zero values in the output (e.g., return "1 d" and not "0 wk, 1 d, 0 hr, 0 min, 0 sec"). Give larger units precedence over smaller ones as much as possible (e.g., return 2 min, 10 sec and not 1 min, 70 sec or 130 sec) Mimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).	#zkl	zkl	fcn toWDHMS(sec){ //-->(wk,d,h,m,s) r,b:=List(),0; foreach u in (T(60,60,24,7)){ sec,b=sec.divr(u); // aka divmod r.append(b); } r.append(sec).reverse() }
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Perl	Perl	use threads; use Time::HiRes qw(sleep); $_->join for map { threads->create(sub { sleep rand; print shift, "\n"; }, $_) } qw(Enjoy Rosetta Code);
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Phix	Phix	without js -- (threads) procedure echo(string s) sleep(rand(100)/100) enter_cs() puts(1,s) puts(1,'\n') leave_cs() end procedure constant threads = {create_thread(routine_id("echo"),{"Enjoy"}), create_thread(routine_id("echo"),{"Rosetta"}), create_thread(routine_id("echo"),{"Code"})} wait_thread(threads) puts(1,"done") {} = wait_key()
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Oz	Oz	functor import System Application prepare fun {Fac N} {FoldL {List.number 1 N 1} Number.'*' 1} end Fac10 = {Fac 10} define {System.showInfo "10! = "#Fac10} {Application.exit 0} end
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Pascal	Pascal	program in out; const X = 1098765432*1 ; begin writeln(x); end;
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Perl	Perl	my $tenfactorial; print "$tenfactorial\n"; BEGIN {$tenfactorial = 1; $tenfactorial *= $_ foreach 1 .. 10;}
http://rosettacode.org/wiki/Conditional_structures	Conditional structures	Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.	#68000_Assembly	68000 Assembly	MOVE.L #$FFFFFF00,D0 CMP.B #0,D0 ;equals zero, so zero flag is set. CMP.W #0,D0 ;doesn't equals zero, so zero flag is clear.
http://rosettacode.org/wiki/Conway%27s_Game_of_Life	Conway's Game of Life	The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.	#Ada	Ada	WITH Ada.Text_IO; USE Ada.Text_IO; PROCEDURE Life IS SUBTYPE Cell IS Natural RANGE 0 .. 1; TYPE Petri_Dish IS ARRAY (Positive RANGE <>, Positive RANGE <>) OF Cell; PROCEDURE Step (Gen : IN OUT Petri_Dish) IS Above : ARRAY (Gen'Range (2)) OF Cell := (OTHERS => 0); Left, This : Cell; BEGIN FOR I IN Gen'First (1) + 1 .. Gen'Last (1) - 1 LOOP Left := 0; FOR J IN Gen'First (2) + 1 .. Gen'Last (2) - 1 LOOP This := (CASE Above (J - 1) + Above (J) + Above (J + 1) + Left + Gen (I, J + 1) + Gen (I + 1, J - 1) + Gen (I + 1, J) + Gen (I + 1, J + 1) IS WHEN 2 => Gen (I, J), WHEN 3 => 1, WHEN OTHERS => 0); Above (J - 1):= Left; Left := Gen (I, J); Gen (I, J) := This; END LOOP; Above (Above'Last - 1) := Left; END LOOP; END Step; PROCEDURE Put (Gen : Petri_Dish) IS BEGIN FOR I IN Gen'Range (1) LOOP FOR J IN Gen'Range (2) LOOP Put ( if Gen (I, J) = 0 then " " else "#"); END LOOP; New_Line; END LOOP; END Put; Blinker : Petri_Dish := (2 .. 4 => (0, 0, 1, 0, 0), 1 \| 5 => (0, 0, 0, 0, 0)); Glider : Petri_Dish (1..6,1..11):= (2 => (3 => 1, others => 0), 3 => (4 => 1, others => 0), 4 => (2\|3\|4=>1, others => 0), others => (others => 0)); PROCEDURE Put_And_Step_Generation (N : Positive; Name : String; P : IN OUT Petri_Dish) IS BEGIN FOR Generation IN 1 .. N LOOP Put_Line (Name & Generation'Img); Put (P); Step (P); END LOOP; END Put_And_Step_Generation; BEGIN Put_And_Step_Generation (3, "Blinker", Blinker); Put_And_Step_Generation (5, "Glider", Glider); END Life;
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#KonsolScript	KonsolScript	Var:Create( Point, Number x, Number y )
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Kotlin	Kotlin	data class Point(var x: Int, var y: Int) fun main(args: Array<String>) { val p = Point(1, 2) println(p) p.x = 3 p.y = 4 println(p) }
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Ruby	Ruby	original = "hello" reference = original # copies reference copy1 = original.dup # instance of original.class copy2 = String.new(original) # instance of String original << " world!" # append p reference #=> "hello world!" p copy1 #=> "hello" p copy2 #=> "hello"
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Run_BASIC	Run BASIC	origString$ = "Hello!" ' create original string newString$ = origString$ ' make new strig from original
http://rosettacode.org/wiki/Constrained_random_points_on_a_circle	Constrained random points on a circle	Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.	#PL.2FI	PL/I	constrain: procedure options (main); declare 1 point (100), 2 x fixed binary, 2 y fixed binary; declare (i, j, a, b, c) fixed binary; j = 0; do i = 1 to 100; a = 30random()-15; b = 30random()-15; c = sqrt(a2 + b2); if abs(c) >= 10 & abs(c) <= 15 then do; j = j + 1; x(j) = a; y(j) = b; end; end; /* PLOT / declare table(-15:15, -15:15) character (1); table = ' '; do i = 1 to j; table(x(i), y(i)) = ''; end; do i = -15 to 15; put skip; do j = -15 to 15; put edit (table(i,j)) (a); end; end; end constrain;
http://rosettacode.org/wiki/Convex_hull	Convex hull	Find the points which form a convex hull from a set of arbitrary two dimensional points. For example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15). See also Convex Hull (youtube) http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/	#Visual_Basic_.NET	Visual Basic .NET	Imports ConvexHull Module Module1 Class Point : Implements IComparable(Of Point) Public Property X As Integer Public Property Y As Integer Public Sub New(x As Integer, y As Integer) Me.X = x Me.Y = y End Sub Public Function CompareTo(other As Point) As Integer Implements IComparable(Of Point).CompareTo Return X.CompareTo(other.X) End Function Public Overrides Function ToString() As String Return String.Format("({0}, {1})", X, Y) End Function End Class Function ConvexHull(p As List(Of Point)) As List(Of Point) If p.Count = 0 Then Return New List(Of Point) End If p.Sort() Dim h As New List(Of Point) ' Lower hull For Each pt In p While h.Count >= 2 AndAlso Not Ccw(h(h.Count - 2), h(h.Count - 1), pt) h.RemoveAt(h.Count - 1) End While h.Add(pt) Next ' Upper hull Dim t = h.Count + 1 For i = p.Count - 1 To 0 Step -1 Dim pt = p(i) While h.Count >= t AndAlso Not Ccw(h(h.Count - 2), h(h.Count - 1), pt) h.RemoveAt(h.Count - 1) End While h.Add(pt) Next h.RemoveAt(h.Count - 1) Return h End Function Function Ccw(a As Point, b As Point, c As Point) As Boolean Return ((b.X - a.X) * (c.Y - a.Y)) > ((b.Y - a.Y) * (c.X - a.X)) End Function Sub Main() Dim points As New List(Of Point) From { New Point(16, 3), New Point(12, 17), New Point(0, 6), New Point(-4, -6), New Point(16, 6), New Point(16, -7), New Point(16, -3), New Point(17, -4), New Point(5, 19), New Point(19, -8), New Point(3, 16), New Point(12, 13), New Point(3, -4), New Point(17, 5), New Point(-3, 15), New Point(-3, -9), New Point(0, 11), New Point(-9, -3), New Point(-4, -2), New Point(12, 10) } Dim hull = ConvexHull(points) Dim it = hull.GetEnumerator() Console.Write("Convex Hull: [") If it.MoveNext() Then Console.Write(it.Current) End If While it.MoveNext() Console.Write(", {0}", it.Current) End While Console.WriteLine("]") End Sub End Module
http://rosettacode.org/wiki/Convert_seconds_to_compound_duration	Convert seconds to compound duration	Task Write a function or program which: takes a positive integer representing a duration in seconds as input (e.g., 100), and returns a string which shows the same duration decomposed into: weeks, days, hours, minutes, and seconds. This is detailed below (e.g., "2 hr, 59 sec"). Demonstrate that it passes the following three test-cases: Test Cases input number output string 7259 2 hr, 59 sec 86400 1 d 6000000 9 wk, 6 d, 10 hr, 40 min Details The following five units should be used: unit suffix used in output conversion week wk 1 week = 7 days day d 1 day = 24 hours hour hr 1 hour = 60 minutes minute min 1 minute = 60 seconds second sec However, only include quantities with non-zero values in the output (e.g., return "1 d" and not "0 wk, 1 d, 0 hr, 0 min, 0 sec"). Give larger units precedence over smaller ones as much as possible (e.g., return 2 min, 10 sec and not 1 min, 70 sec or 130 sec) Mimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).	#ZX_Spectrum_Basic	ZX Spectrum Basic	10 LET m=60: LET h=60m: LET d=h24: LET w=d7 20 DATA 10,7259,86400,6000000,0,1,60,3600,604799,604800,694861 30 READ n 40 FOR i=1 TO n 50 READ s 60 LET nweek=0: LET nday=0: LET nhour=0: LET nmin=0: LET nsec=0: LET s$="" 70 PRINT s;" = "; 80 IF s>=w THEN LET nweek=INT (s/w): LET s=FN m(s,w) 90 IF s>=d THEN LET nday=INT (s/d): LET s=FN m(s,d) 100 IF s>=h THEN LET nhour=INT (s/h): LET s=FN m(s,h) 110 IF s>=m THEN LET nmin=INT (s/m): LET s=FN m(s,m) 120 LET nsec=INT (s) 130 IF nweek>0 THEN LET s$=s$+STR$ nweek+" wk, " 140 IF nday>0 THEN LET s$=s$+STR$ nday+" d, " 150 IF nhour>0 THEN LET s$=s$+STR$ nhour+" hr, " 160 IF nmin>0 THEN LET s$=s$+STR$ nmin+" min, " 170 IF nsec>0 THEN LET s$=s$+STR$ nsec+" sec" 180 IF s$<>"" THEN IF s$(LEN s$-1)="," THEN LET s$=s$( TO LEN s$-2) 190 PRINT s$ 200 NEXT i 210 STOP 220 DEF FN m(a,b)=a-INT (a/b)b
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#PicoLisp	PicoLisp	(for (N . Str) '("Enjoy" "Rosetta" "Code") (task (- N) (rand 1000 4000) # Random start time 1 .. 4 sec Str Str # Closure with string value (println Str) # Task body: Print the string (task @) ) ) # and stop the task
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Pike	Pike	int main() { // Start threads and wait for them to finish ({ Thread.Thread(write, "Enjoy\n"), Thread.Thread(write, "Rosetta\n"), Thread.Thread(write, "Code\n") })->wait(); // Exit program exit(0); }
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Phix	Phix	integer a,b a = 1098765432*1 b = factorial(10) ?{a,b}
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#PicoLisp	PicoLisp	(de fact (N) (apply * (range 1 N)) ) (de foo () (prinl "The value of fact(10) is " `(fact 10)) )
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#PL.2FI	PL/I	/* Factorials using the pre-processor. / test: procedure options (main); %factorial: procedure (N) returns (fixed); declare N fixed; declare (i, k) fixed; k = 1; do i = 2 to N; k = ki; end; return (k); %end factorial; %activate factorial; declare (x, y) fixed decimal; x = factorial (4); put ('factorial 4 is ', x); y = factorial (6); put skip list ('factorial 6 is ', y); end test;
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#PowerShell	PowerShell	function fact([BigInt]$n){ if($n -ge ([BigInt]::Zero)) { $fact = [BigInt]::One ([BigInt]::One)..$n \| foreach{ $fact = [BigInt]::Multiply($fact, $_) } $fact } else { Write-Error "$n is lower than 0" } } "$((Measure-Command {$fact = fact 10}).TotalSeconds) Seconds" $fact
http://rosettacode.org/wiki/Conditional_structures	Conditional structures	Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.	#AArch64_Assembly	AArch64 Assembly	/* ARM assembly AARCH64 Raspberry PI 3B / / program condstr64.s / /*****************************************/ / Constantes file / /*****************************************/ / for this file see task include a file in language AArch64 assembly/ .include "../includeConstantesARM64.inc" /*****************************************/ / Initialized data / /****************************************/ .data szMessTest1: .asciz "The test 1 is equal.\n" szMessTest1N: .asciz "The test 1 is not equal.\n" szMessTest1A: .asciz "The test 1A is equal.\n" szMessTest1AN: .asciz "The test 1A is not equal.\n" szMessTest2: .asciz "The test 2 is equal.\n" szMessTest2N: .asciz "The test 2 is not equal.\n" szMessTest3: .asciz "The test 3 is <.\n" szMessTest3N: .asciz "The test 3 is >.\n" szMessTest4: .asciz "The test 4 is <=.\n" szMessTest4N: .asciz "The test 4 is >.\n" szMessTest5: .asciz "The test 5 is negative.\n" szMessTest5N: .asciz "The test 5 is positive ou equal 0.\n" szMessTest6: .asciz "Test 6 : carry is off.\n" szMessTest6N: .asciz "Test 6 : carry is set.\n" szMessTest7: .asciz "Test 7 : no overflow.\n" szMessTest7N: .asciz "Test 7 : overflow.\n" szMessTest8: .asciz "Test 8 : then.\n" szMessTest8N: .asciz "Test 8 : else.\n" szMessResult: .asciz "Test result = @ \n" /****************************************/ / UnInitialized data / /****************************************/ .bss sZoneConv: .skip 30 /****************************************/ / code section / /****************************************/ .text .global main main: // entry of program // classic test equal zero, not equal zero //mov x1,0 // comments mov x1,1 // or uncomments cmp x1,0 // structure if else bne 1f ldr x0,qAdrszMessTest1 // if equal b 2f 1: ldr x0,qAdrszMessTest1N // else 2: bl affichageMess mov x1,0 // comments //mov x1,1 // or uncomments cbnz x1,3f // other test and branch if not zero ldr x0,qAdrszMessTest1A b 4f 3: ldr x0,qAdrszMessTest1AN 4: bl affichageMess // test equal 5, not equal 5 //mov x1,#5 mov x1,10 cmp x1,5 bne 5f ldr x0,qAdrszMessTest2 b 6f 5: ldr x0,qAdrszMessTest2N 6: bl affichageMess // test < 5, > 5 SIGNED mov x1,#-10 //mov x1,#10 cmp x1,#5 bgt 7f ldr x0,qAdrszMessTest3 b 8f 7: ldr x0,qAdrszMessTest3N 8: bl affichageMess // test < 5, > 5 UNSIGNED //mov x1,#-10 mov x1,#2 cmp x1,#5 bhi 9f ldr x0,qAdrszMessTest4 b 10f 9: ldr x0,qAdrszMessTest4N 10: bl affichageMess // test < 0, > 0 mov x1,2 subs x1,x1,5 // s --> flags bpl 11f ldr x0,qAdrszMessTest5 b 12f 11: ldr x0,qAdrszMessTest5N 12: bl affichageMess // carry off carry on //mov x1,#-10 // for carry set //mov x1,#10 // for carry off mov x1,(2<<62) - 1 // for carry off adds x1,x1,20 // s --> flags bcs 13f ldr x0,qAdrszMessTest6 // carry clear b 14f 13: ldr x0,qAdrszMessTest6N // carry set 14: bl affichageMess // overflow off overflow on //mov x1,#-10 // for not overflow //mov x1,#10 // for not overflow mov x1,(2<<62) - 1 // for overflow adds x1,x1,20 // s --> flags bvs 15f ldr x0,qAdrszMessTest7 // overflow off b 16f 15: ldr x0,qAdrszMessTest7N // overflow on 16: bl affichageMess // other conditionnel test csel mov x2,-20 mov x3,25 mov x1,10 // for equal //mov x1,#20 // for else cmp x1,10 csel x0,x2,x3,eq // if x1=10 x0 = x2 else x0 = x3 ldr x1,qAdrsZoneConv bl conversion10S ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv bl strInsertAtCharInc // insert result at @ character bl affichageMess // other conditionnel test cset //mov x1,10 // for equal mov x1,20 // for else cmp x1,10 cset x0,eq // if x1=10 x0 = 1 else x0 = 0 ldr x1,qAdrsZoneConv bl conversion10S ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv bl strInsertAtCharInc // insert result at @ character bl affichageMess // other conditionnel test cinc mov x0,3 mov x1,10 // for equal //mov x1,20 // for else cmp x1,10 cinc x0,x0,eq // if x1=10 x0 = x0+1 else x0 = x0 ldr x1,qAdrsZoneConv bl conversion10S ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv bl strInsertAtCharInc // insert result at @ character bl affichageMess // other conditionnel test csinc mov x0,3 mov x2,6 mov x3,11 mov x1,10 // for equal //mov x1,20 // for else cmp x1,10 csinc x0,x2,x3,ne // if x1<>10 x0 = x2 else x0 = x3 + 1 ldr x1,qAdrsZoneConv bl conversion10S ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv bl strInsertAtCharInc // insert result at @ character bl affichageMess 100: // standard end of the program mov x0,0 // return code mov x8,EXIT // request to exit program svc 0 // perform the system call qAdrszMessTest1: .quad szMessTest1 qAdrszMessTest1N: .quad szMessTest1N qAdrszMessTest1A: .quad szMessTest1A qAdrszMessTest1AN: .quad szMessTest1AN qAdrszMessTest2: .quad szMessTest2 qAdrszMessTest2N: .quad szMessTest2N qAdrszMessTest3: .quad szMessTest3 qAdrszMessTest3N: .quad szMessTest3N qAdrszMessTest4: .quad szMessTest4 qAdrszMessTest4N: .quad szMessTest4N qAdrszMessTest5: .quad szMessTest5 qAdrszMessTest5N: .quad szMessTest5N qAdrszMessTest6: .quad szMessTest6 qAdrszMessTest6N: .quad szMessTest6N qAdrszMessTest7: .quad szMessTest7 qAdrszMessTest7N: .quad szMessTest7N qAdrszMessTest8: .quad szMessTest8 qAdrszMessTest8N: .quad szMessTest8N qAdrszMessResult: .quad szMessResult qAdrsZoneConv: .quad sZoneConv /*****************************************************/ / File Include fonctions / /******************************************************/ / for this file see task include a file in language AArch64 assembly */ .include "../includeARM64.inc"
http://rosettacode.org/wiki/Conway%27s_Game_of_Life	Conway's Game of Life	The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.	#ALGOL_68	ALGOL 68	∇LIFE[⎕]∇ [0] NG←LIFE CG;W [1] W←CG+(¯1⊖CG)+(1⊖CG)+(¯1⌽CG)+(1⌽CG) [2] W←W+(1⊖1⌽CG)+(¯1⊖1⌽CG)+(1⊖¯1⌽CG)+(¯1⊖¯1⌽CG) [3] NG←(3=W)+(CG∧4=W) ∇ RP←5 5⍴0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 RP 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 LIFE RP 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 LIFE LIFE RP 0 0 1 0 0 0 1 1 0 0 1 0 0 1 0 0 1 1 0 0 0 0 0 0 0
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Lambdatalk	Lambdatalk	1) a pair {def P {P.new 1 2}} -> P {P.left {P}} -> 1 {P.right {P}} -> 2 2) its Lispsish variant {def Q {cons 1 2}} -> Q {car {Q}} -> 1 {cdr {Q}} -> 2 3) as an array {def R {A.new 1 2}} -> R {A.first {R}} -> 1 {A.last {R}} -> 2
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Lasso	Lasso	define Point => type { parent pair public onCreate(x,y) => { ..onCreate(#x=#y) } public x => .first public y => .second } local(point) = Point(33, 42) #point->x #point->y
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Rust	Rust	fn main() { let s1 = "A String"; let mut s2 = s1; s2 = "Another String"; println!("s1 = {}, s2 = {}", s1, s2); }
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Sather	Sather	class MAIN is main is s ::= "a string"; s1 ::= s; -- s1 is a copy end; end;
http://rosettacode.org/wiki/Constrained_random_points_on_a_circle	Constrained random points on a circle	Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.	#PowerShell	PowerShell	$MinR2 = 10 * 10 $MaxR2 = 15 * 15 $Points = @{} While ( $Points.Count -lt 100 ) { $X = Get-Random -Minimum -16 -Maximum 17 $Y = Get-Random -Minimum -16 -Maximum 17 $R2 = $X * $X + $Y * $Y If ( $R2 -ge $MinR2 -and $R2 -le $MaxR2 -and "$X,$Y" -notin $Points.Keys ) { $Points += @{ "$X,$Y" = 1 } } } ForEach ( $Y in -16..16 ) { ( -16..16 \| ForEach { ( " ", "*" )[[int]$Points["$_,$Y"]] } ) -join '' }
http://rosettacode.org/wiki/Convex_hull	Convex hull	Find the points which form a convex hull from a set of arbitrary two dimensional points. For example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15). See also Convex Hull (youtube) http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/	#Wren	Wren	import "/sort" for Sort import "/trait" for Comparable, Stepped class Point is Comparable { construct new(x, y) { _x = x _y = y } x { _x } y { _y } compare(other) { (_x != other.x) ? (_x - other.x).sign : (_y - other.y).sign } toString { "(%(_x), %(_y))" } } /* ccw returns true if the three points make a counter-clockwise turn / var ccw = Fn.new { \|a, b, c\| ((b.x - a.x) (c.y - a.y)) > ((b.y - a.y) * (c.x - a.x)) } var convexHull = Fn.new { \|pts\| if (pts.isEmpty) return [] Sort.quick(pts) var h = [] // lower hull for (pt in pts) { while (h.count >= 2 && !ccw.call(h[-2], h[-1], pt)) h.removeAt(-1) h.add(pt) } // upper hull var t = h.count + 1 for (i in Stepped.descend(pts.count-2..0, 1)) { var pt = pts[i] while (h.count >= t && !ccw.call(h[-2], h[-1], pt)) h.removeAt(-1) h.add(pt) } h.removeAt(-1) return h } var pts = [ Point.new(16, 3), Point.new(12, 17), Point.new( 0, 6), Point.new(-4, -6), Point.new(16, 6), Point.new(16, -7), Point.new(16, -3), Point.new(17, -4), Point.new( 5, 19), Point.new(19, -8), Point.new( 3, 16), Point.new(12, 13), Point.new( 3, -4), Point.new(17, 5), Point.new(-3, 15), Point.new(-3, -9), Point.new( 0, 11), Point.new(-9, -3), Point.new(-4, -2), Point.new(12, 10) ] System.print("Convex Hull: %(convexHull.call(pts))")
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#PowerShell	PowerShell	$Strings = "Enjoy","Rosetta","Code" $SB = {param($String)Write-Output $String} foreach($String in $Strings) { Start-Job -ScriptBlock $SB -ArgumentList $String \| Out-Null } Get-Job \| Wait-Job \| Receive-Job Get-Job \| Remove-Job
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Prolog	Prolog	main :- thread_create(say("Enjoy"),A,[]), thread_create(say("Rosetta"),B,[]), thread_create(say("Code"),C,[]), thread_join(A,_), thread_join(B,_), thread_join(C,_). say(Message) :- Delay is random_float, sleep(Delay), writeln(Message).
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Prolog	Prolog	% Taken from RosettaCode Factorial page for Prolog fact(X, 1) :- X<2. fact(X, F) :- Y is X-1, fact(Y,Z), F is Z*X. goal_expansion((X = factorial_of(N)), (X = F)) :- fact(N,F). test :- F = factorial_of(10), format('!10 = ~p~n', F).
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#PureBasic	PureBasic	a=123456789*10
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Quackery	Quackery	[ 1 10 times [ i 1+ * ] echo ] now!
http://rosettacode.org/wiki/Conditional_structures	Conditional structures	Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.	#Action.21	Action!	PROC Main() INT i FOR i=-1 TO 1 DO IF i<0 THEN PrintF("%I is less than zero%E",i) ELSEIF i>0 THEN PrintF("%I is greater than zero%E",i) ELSE PrintF("%I is zero%E",i) FI OD RETURN
http://rosettacode.org/wiki/Conway%27s_Game_of_Life	Conway's Game of Life	The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.	#APL	APL	∇LIFE[⎕]∇ [0] NG←LIFE CG;W [1] W←CG+(¯1⊖CG)+(1⊖CG)+(¯1⌽CG)+(1⌽CG) [2] W←W+(1⊖1⌽CG)+(¯1⊖1⌽CG)+(1⊖¯1⌽CG)+(¯1⊖¯1⌽CG) [3] NG←(3=W)+(CG∧4=W) ∇ RP←5 5⍴0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 RP 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 LIFE RP 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 LIFE LIFE RP 0 0 1 0 0 0 1 1 0 0 1 0 0 1 0 0 1 1 0 0 0 0 0 0 0
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#LFE	LFE	(defrecord point x y)
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Lingo	Lingo	-- parent script "MyPoint" property x property y on new (me, px, py) me.x = px me.y = py return me end
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Scala	Scala	val src = "Hello" // Its actually not a copy but a reference // That is not a problem because String is immutable // In fact its a feature val des = src assert(src eq des) // Proves the same reference is used. // To make a real copy makes no sense. // Actually its hard to make a copy, the compiler is too smart. // mkString, toString makes also not a real copy val cop = src.mkString.toString assert((src eq cop)) // Still no copyed image val copy = src.reverse.reverse // Finally double reverse makes a copy assert(src == copy && !(src eq copy))// Prove, but it really makes no sense.
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Scheme	Scheme	(define dst (string-copy src))
http://rosettacode.org/wiki/Constrained_random_points_on_a_circle	Constrained random points on a circle	Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.	#Prolog	Prolog	:- use_module(library(clpfd)). circle :- bagof([X,Y], init(X,Y), BL), length(BL, N), length(L, 100), maplist(choose(BL, N), L), draw_circle(L). % point selection choose(BL, N, V) :- I is random(N), nth0(I, BL, V). % to find all couples of numbers verifying % 100 <= x^2 + y^2 <= 225 init(X1, Y1) :- X in -15..15, Y in -15..15, XX + YY #>= 100, XX + YY #=< 225, label([X,Y]), X1 is 10 * X + 200, Y1 is 10 * Y + 200. draw_circle(L) :- new(D, window('Circle')), send(D, size,size(400,400)), forall(member([X,Y], L), ( new(C, circle(4)), send(C, fill_pattern, colour(@default, 0, 0, 0)), send(C, center(point(X,Y))), send(D, display, C))), send(D, open).
http://rosettacode.org/wiki/Convex_hull	Convex hull	Find the points which form a convex hull from a set of arbitrary two dimensional points. For example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15). See also Convex Hull (youtube) http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/	#zkl	zkl	// Use Graham Scan to sort points into a convex hull // https://en.wikipedia.org/wiki/Graham_scan, O(n log n) // http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/ // http://geomalgorithms.com/a10-_hull-1.html fcn grahamScan(points){ N:=points.len(); # find the point with the lowest y-coordinate, x is tie breaker p0:=points.reduce(fcn([(a,b)]ab,[(x,y)]xy){ if(b<y)ab else if(b==y and a<x)ab else xy }); #sort points by polar angle with p0, ie ccw from p0 points.sort('wrap(p1,p2){ ccw(p0,p1,p2)>0 }); # We want points[0] to be a sentinel point that will stop the loop. points.insert(0,points[-1]); M:=1; # M will denote the number of points on the convex hull. foreach i in ([2..N]){ # Find next valid point on convex hull. while(ccw(points[M-1], points[M], points[i])<=0){ if(M>1) M-=1; else if(i==N) break; # All points are collinear else i+=1; } points.swap(M+=1,i); # Update M and swap points[i] to the correct place. } points[0,M] } # Three points are a counter-clockwise turn if ccw > 0, clockwise if # ccw < 0, and collinear if ccw = 0 because ccw is a determinant that # gives twice the signed area of the triangle formed by p1, p2 and p3. fcn ccw(a,b,c){ // a,b,c are points: (x,y) ((b[0] - a[0])(c[1] - a[1])) - ((b[1] - a[1])(c[0] - a[0])) }
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#PureBasic	PureBasic	Global mutex = CreateMutex() Procedure Printer(str) LockMutex(mutex) PrintN( PeekS(str) ) UnlockMutex(mutex) EndProcedure If OpenConsole() LockMutex(mutex) thread1 = CreateThread(@Printer(), @"Enjoy") thread2 = CreateThread(@Printer(), @"Rosetta") thread3 = CreateThread(@Printer(), @"Code") UnlockMutex(mutex) WaitThread(thread1) WaitThread(thread2) WaitThread(thread3) Print(#CRLF$ + #CRLF$ + "Press ENTER to exit") Input() CloseConsole() EndIf FreeMutex(mutex)
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Python	Python	import asyncio async def print_(string: str) -> None: print(string) async def main(): strings = ['Enjoy', 'Rosetta', 'Code'] coroutines = map(print_, strings) await asyncio.gather(*coroutines) if __name__ == '__main__': asyncio.run(main())
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Racket	Racket	#lang racket ;; Import the math library for compile-time ;; Note: included in Racket v5.3.2 (require (for-syntax math)) ;; In versions older than v5.3.2, just define the function ;; for compile-time ;; ;; (begin-for-syntax ;; (define (factorial n) ;; (if (zero? n) ;; 1 ;; (factorial (- n 1))))) ;; define a macro that calls factorial at compile-time (define-syntax (fact10 stx) #`#,(factorial 10)) ;; use the macro defined above (fact10)
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Raku	Raku	constant $tenfact = [*] 2..10; say $tenfact;
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#REXX	REXX	/REXX program computes 10! (ten factorial) during REXX's equivalent of "compile─time". / say '10! =' !(10) exit /stick a fork in it, we're all done. / /──────────────────────────────────────────────────────────────────────────────────────/ !: procedure; !=1; do j=2 to arg(1); !=!j; end /j*/; return !
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Ring	Ring	a = 10987654321 b = factorial(10) see a + nl see b + nl func factorial nr if nr = 1 return 1 else return nr factorial(nr-1) ok
http://rosettacode.org/wiki/Conditional_structures	Conditional structures	Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.	#ActionScript	ActionScript	type Restricted is range 1..10; My_Var : Restricted; if My_Var = 5 then -- do something elsif My_Var > 5 then -- do something else -- do something end if;
http://rosettacode.org/wiki/Conway%27s_Game_of_Life	Conway's Game of Life	The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.	#AppleScript	AppleScript	use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later use framework "Foundation" -- For the regex at the top of newUniverse() use scripting additions -- The characters to represent the live and dead cells. property live : "■" -- character id 9632 (U+25A0). property dead : space -- Infinite universes are expensive to maintain, so only a local region of universe is represented here. -- Its invisible border is a wall of "dead" cells one cell deep, lined with a two-cell buffer layer into which -- objects nominally leaving the region can disappear without being seen to hit the wall or bouncing back. property borderThickness : 3 on newUniverse(seed, {w, h}) -- Replace every visible character in the seed text with "■" and every horizontal space with a space. set seed to current application's class "NSMutableString"'s stringWithString:(seed) set regex to current application's NSRegularExpressionSearch tell seed to replaceOccurrencesOfString:("\\S") withString:(live) options:(regex) range:({0, its \|length\|()}) tell seed to replaceOccurrencesOfString:("\\h") withString:(dead) options:(regex) range:({0, its \|length\|()}) -- Ensure the universe dimensions are at least equal to the number of lines and the length of the longest. set seedLines to paragraphs of (seed as text) set lineCount to (count seedLines) if (lineCount > h) then set h to lineCount set seedWidth to 0 repeat with thisLine in seedLines set lineLength to (count thisLine) if (lineLength > seedWidth) then set seedWidth to lineLength end repeat if (seedWidth > w) then set w to seedWidth -- Get a new universe. script universe -- State lists. These will contain or be lists of 0s and 1s and will include the border cells. property newState : {} property previousState : {} property currentRow : {} property rowAbove : {} property rowBelow : {} property replacementRow : {} -- Equivalent text lists. These will only cover what's in the bounded region. property lineList : {} property characterGrid : {} property currentLineCharacters : {} -- Precalculated border cell indices. property rightInnerBuffer : borderThickness + w + 1 property rightOuterBuffer : rightInnerBuffer + borderThickness - 2 property bottomInnerBuffer : borderThickness + h + 1 property bottomOuterBuffer : bottomInnerBuffer + borderThickness - 2 -- Generation counter. property counter : 0 -- Temporary lists used in the set-up. property rowTemplate : {} property lineCharacterTemplate : {} -- Built-in handlers. Both return text representing a universe state and -- a boolean indicating whether or not the state's the same as the previous one. on nextState() set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to "" copy newState to previousState set currentRow to beginning of my previousState set rowBelow to item 2 of my previousState -- Check each occupiable cell in each occupiable row of the 'previousState' grid, including the buffer cells. -- If warranted by the number of live neighbours, edit the equivalent cell in 'newState' and, -- if within the region's bounds, change the corresponding text character too. repeat with r from 2 to bottomOuterBuffer set rowAbove to currentRow set currentRow to rowBelow set rowBelow to item (r + 1) of my previousState set replacementRow to item r of my newState set rowCrossesRegion to ((r comes after borderThickness) and (r comes before bottomInnerBuffer)) if (rowCrossesRegion) then set currentLineCharacters to item (r - borderThickness) of my characterGrid set lineChanged to false repeat with c from 2 to rightOuterBuffer set liveNeighbours to ¬ (item (c - 1) of my rowAbove) + (item c of my rowAbove) + (item (c + 1) of my rowAbove) + ¬ (item (c - 1) of my currentRow) + (item (c + 1) of my currentRow) + ¬ (item (c - 1) of my rowBelow) + (item c of my rowBelow) + (item (c + 1) of my rowBelow) if (item c of my currentRow is 1) then if ((liveNeighbours < 2) or (liveNeighbours > 3)) then set item c of my replacementRow to 0 if ((c comes after borderThickness) and (c comes before rightInnerBuffer) and (rowCrossesRegion)) then set item (c - borderThickness) of my currentLineCharacters to dead set lineChanged to true else if ((c is 3) or (c is rightOuterBuffer) or (r is 3) or (r is bottomOuterBuffer)) then -- This is a fudge to dissolve "bombers" entering the buffer zone. set item (c - 1) of my replacementRow to -1 set item c of item (r - 1) of my newState to -1 end if end if else if (liveNeighbours is 3) then set item c of my replacementRow to 1 if ((c comes after borderThickness) and (c comes before rightInnerBuffer) and (rowCrossesRegion)) then set item (c - borderThickness) of my currentLineCharacters to live set lineChanged to true end if end if end repeat if (lineChanged) then set item (r - borderThickness) of my lineList to currentLineCharacters as text end repeat set AppleScript's text item delimiters to astid set counter to counter + 1 set last item of my lineList to "Generation " & counter return currentState() end nextState on currentState() set noChanges to (newState = previousState) if (noChanges) then ¬ set last item of my lineList to (last item of my lineList) & " (all dead, still lifes, or left the universe)" set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to return set stateText to lineList as text set AppleScript's text item delimiters to astid return {stateText, noChanges} end currentState end script -- Set the universe's start conditions. -- Build a row template list containing w + 2 * borderThickness zeros -- and a line character template list containing w 'dead' characters. repeat (borderThickness * 2) times set end of universe's rowTemplate to 0 end repeat repeat w times set end of universe's rowTemplate to 0 set end of universe's lineCharacterTemplate to dead end repeat set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to "" set blankLine to universe's lineCharacterTemplate as text -- Use the templates to populate lists representing the universe's conditions. -- Firstly the top border rows ('newState' list only). repeat borderThickness times copy universe's rowTemplate to end of universe's newState end repeat -- Then enough rows and text lines to centre the input roughly halfway down the grid. set headroom to (h - lineCount) div 2 repeat headroom times copy universe's rowTemplate to end of universe's newState copy universe's lineCharacterTemplate to end of universe's characterGrid set end of universe's lineList to blankLine end repeat -- Then the rows and lines representing the input itself, centring it roughly halfway across the grid. set textInset to (w - seedWidth) div 2 set stateInset to textInset + borderThickness repeat with thisLine in seedLines copy universe's rowTemplate to universe's currentRow copy universe's lineCharacterTemplate to universe's currentLineCharacters repeat with c from 1 to (count thisLine) set thisCharacter to character c of thisLine set item (textInset + c) of universe's currentLineCharacters to thisCharacter set item (stateInset + c) of universe's currentRow to (thisCharacter is live) as integer end repeat set end of universe's newState to universe's currentRow set end of universe's characterGrid to universe's currentLineCharacters set end of universe's lineList to universe's currentLineCharacters as text end repeat set AppleScript's text item delimiters to astid -- Then the rows and lines beneath and the bottom border. repeat (h - (headroom + lineCount)) times copy universe's rowTemplate to end of universe's newState copy universe's lineCharacterTemplate to end of universe's characterGrid set end of universe's lineList to blankLine end repeat repeat borderThickness times copy universe's rowTemplate to end of universe's newState end repeat -- Add a generation counter display line to the end of the line list. set end of universe's lineList to "Generation 0" -- Lose the no-longer-needed template lists. set universe's rowTemplate to missing value set universe's lineCharacterTemplate to universe's rowTemplate return universe end newUniverse
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Logo	Logo	setpos [100 100] setpos [100 0] setpos [0 0] show pos ; [0 0]
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Lua	Lua	a = {x = 1; y = 2} b = {x = 3; y = 4} c = { x = a.x + b.x; y = a.y + b.y } print(a.x, a.y) --> 1 2 print(c.x, c.y) --> 4 6
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Seed7	Seed7	var string: dest is ""; dest := "Hello";
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#SenseTalk	SenseTalk	(* In SenseTalk, assignments normally always make copies of values. ) put "glorious" into myWord put myWord into yourWord ( Assignments can also be made by reference if desired. *) put a reference to myWord into myRef set another to refer to myRef put "ly" after myWord put "in" before another put "myWord: " & myWord put "yourWord: " & yourWord put "myRef: " & myRef put "another: " & another
http://rosettacode.org/wiki/Constrained_random_points_on_a_circle	Constrained random points on a circle	Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.	#PureBasic	PureBasic	CreateImage(0,31,31) StartDrawing(ImageOutput(0)) For i=1 To 100 Repeat x=Random(30)-15 y=Random(30)-15 R.f=Sqr(xx+yy) Until 10<=R And R<=15 Plot(x+15,y+15,#Red) Next StopDrawing() Title$="PureBasic Plot" Flags=#PB_Window_SystemMenu OpenWindow(0,#PB_Ignore,#PB_Ignore,ImageWidth(0),ImageHeight(0),Title$,Flags) ImageGadget(0,0,0,ImageWidth(0),ImageHeight(0),ImageID(0)) Repeat: Until WaitWindowEvent()=#PB_Event_CloseWindow
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Racket	Racket	#lang racket (for ([str '("Enjoy" "Rosetta" "Code")]) (thread (λ () (displayln str))))
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Raku	Raku	my @words = <Enjoy Rosetta Code>; @words.race(:batch(1)).map: { sleep rand; say $_ };
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Rust	Rust	fn factorial(n: i64) -> i64 { let mut total = 1; for i in 1..n+1 { total *= i; } return total; } fn main() { println!("Factorial of 10 is {}.", factorial(10)); }
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Scala	Scala	object Main extends { val tenFactorial = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 def tenFac = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 println(s"10! = $tenFactorial", tenFac) }
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Seed7	Seed7	$ include "seed7_05.s7i"; const proc: main is func local const integer: factorial is !10; begin writeln(factorial); end func;
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Sidef	Sidef	define n = (10!); say n;
http://rosettacode.org/wiki/Conditional_structures	Conditional structures	Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.	#Ada	Ada	type Restricted is range 1..10; My_Var : Restricted; if My_Var = 5 then -- do something elsif My_Var > 5 then -- do something else -- do something end if;
http://rosettacode.org/wiki/Compiler/AST_interpreter	Compiler/AST interpreter	An AST interpreter interprets an Abstract Syntax Tree (AST) produced by a Syntax Analyzer. Task[edit] Take the AST output from the Syntax analyzer task, and interpret it as appropriate. Refer to the Syntax analyzer task for details of the AST. Loading the AST from the syntax analyzer is as simple as (pseudo code) def load_ast() line = readline() # Each line has at least one token line_list = tokenize the line, respecting double quotes text = line_list[0] # first token is always the node type if text == ";" # a terminal node return NULL node_type = text # could convert to internal form if desired # A line with two tokens is a leaf node # Leaf nodes are: Identifier, Integer, String # The 2nd token is the value if len(line_list) > 1 return make_leaf(node_type, line_list[1]) left = load_ast() right = load_ast() return make_node(node_type, left, right) The interpreter algorithm is relatively simple interp(x) if x == NULL return NULL elif x.node_type == Integer return x.value converted to an integer elif x.node_type == Ident return the current value of variable x.value elif x.node_type == String return x.value elif x.node_type == Assign globals[x.left.value] = interp(x.right) return NULL elif x.node_type is a binary operator return interp(x.left) operator interp(x.right) elif x.node_type is a unary operator, return return operator interp(x.left) elif x.node_type == If if (interp(x.left)) then interp(x.right.left) else interp(x.right.right) return NULL elif x.node_type == While while (interp(x.left)) do interp(x.right) return NULL elif x.node_type == Prtc print interp(x.left) as a character, no newline return NULL elif x.node_type == Prti print interp(x.left) as an integer, no newline return NULL elif x.node_type == Prts print interp(x.left) as a string, respecting newlines ("\n") return NULL elif x.node_type == Sequence interp(x.left) interp(x.right) return NULL else error("unknown node type") Notes: Because of the simple nature of our tiny language, Semantic analysis is not needed. Your interpreter should use C like division semantics, for both division and modulus. For division of positive operands, only the non-fractional portion of the result should be returned. In other words, the result should be truncated towards 0. This means, for instance, that 3 / 2 should result in 1. For division when one of the operands is negative, the result should be truncated towards 0. This means, for instance, that 3 / -2 should result in -1. Test program prime.t lex <prime.t \| parse \| interp /* Simple prime number generator / count = 1; n = 1; limit = 100; while (n < limit) { k=3; p=1; n=n+2; while ((kk<=n) && (p)) { p=n/k*k!=n; k=k+2; } if (p) { print(n, " is prime\n"); count = count + 1; } } print("Total primes found: ", count, "\n"); 3 is prime 5 is prime 7 is prime 11 is prime 13 is prime 17 is prime 19 is prime 23 is prime 29 is prime 31 is prime 37 is prime 41 is prime 43 is prime 47 is prime 53 is prime 59 is prime 61 is prime 67 is prime 71 is prime 73 is prime 79 is prime 83 is prime 89 is prime 97 is prime 101 is prime Total primes found: 26 Additional examples Your solution should pass all the test cases above and the additional tests found Here. Reference The C and Python versions can be considered reference implementations. Related Tasks Lexical Analyzer task Syntax Analyzer task Code Generator task Virtual Machine Interpreter task	#ALGOL_W	ALGOL W	begin % AST interpreter % % parse tree nodes % record node( integer type ; reference(node) left, right ; integer iValue % nString/nIndentifier number or nInteger value % ); integer nIdentifier, nString, nInteger, nSequence, nIf, nPrtc, nPrts , nPrti, nWhile, nAssign, nNegate, nNot, nMultiply , nDivide, nMod, nAdd, nSubtract, nLess, nLessEqual , nGreater, nGreaterEqual, nEqual, nNotEqual, nAnd, nOr ; string(14) array ndName ( 1 :: 25 ); integer MAX_NODE_TYPE; % string literals and identifiers - uses a linked list - a hash table might be better... % string(1) array text ( 0 :: 4095 ); integer textNext, TEXT_MAX; record textElement ( integer start, length; reference(textElement) next ); reference(textElement) idList, stList; % memory - identifiers hold indexes to locations here % integer array data ( 1 :: 4096 ); % returns a new node with left and right branches % reference(node) procedure opNode ( integer value opType; reference(node) value opLeft, opRight ) ; begin node( opType, opLeft, opRight, 0 ) end opNode ; % returns a new operand node % reference(node) procedure operandNode ( integer value opType, opValue ) ; begin node( opType, null, null, opValue ) end operandNode ; % reports an error and stops % procedure rtError( string(80) value message ); begin integer errorPos; write( s_w := 0, "**** Runtime error " ); errorPos := 0; while errorPos < 80 and message( errorPos // 1 ) not = "." do begin writeon( s_w := 0, message( errorPos // 1 ) ); errorPos := errorPos + 1 end while_not_at_end_of_message ; writeon( s_w := 0, "." ); assert( false ) end rtError ; % reads a node from standard input % reference(node) procedure readNode ; begin reference(node) resultNode; % parses a string from line and stores it in a string in the text array % % - if it is not already present in the specified textElement list. % % returns the position of the string in the text array % integer procedure readString ( reference(textElement) value result txList; string(1) value terminator ) ; begin string(256) str; integer sLen, sPos, ePos; logical found; reference(textElement) txPos, txLastPos; % get the text of the string % str := " "; sLen := 0; str( sLen // 1 ) := line( lPos // 1 ); sLen := sLen + 1; lPos := lPos + 1; while lPos <= 255 and line( lPos // 1 ) not = terminator do begin str( sLen // 1 ) := line( lPos // 1 ); sLen := sLen + 1; lPos := lPos + 1 end while_more_string ; if lPos > 255 then rtError( "Unterminated String in node file." ); % attempt to find the text in the list of strings/identifiers % txLastPos := txPos := txList; found := false; ePos := 0; while not found and txPos not = null do begin ePos := ePos + 1; found := ( length(txPos) = sLen ); sPos := 0; while found and sPos < sLen do begin found := str( sPos // 1 ) = text( start(txPos) + sPos ); sPos := sPos + 1 end while_not_found ; txLastPos := txPos; if not found then txPos := next(txPos) end while_string_not_found ; if not found then begin % the string/identifier is not in the list - add it % ePos := ePos + 1; if txList = null then txList := textElement( textNext, sLen, null ) else next(txLastPos) := textElement( textNext, sLen, null ); if textNext + sLen > TEXT_MAX then rtError( "Text space exhausted." ) else begin for cPos := 0 until sLen - 1 do begin text( textNext ) := str( cPos // 1 ); textNext := textNext + 1 end for_cPos end end if_not_found ; ePos end readString ; % gets an integer from the line - no checks for valid digits % integer procedure readInteger ; begin integer n; n := 0; while line( lPos // 1 ) not = " " do begin n := ( n * 10 ) + ( decode( line( lPos // 1 ) ) - decode( "0" ) ); lPos := lPos + 1 end while_not_end_of_integer ; n end readInteger ; string(256) line; string(16) name; integer lPos, tPos, ndType; tPos := lPos := 0; readcard( line ); % get the node type name % while line( lPos // 1 ) = " " do lPos := lPos + 1; name := ""; while lPos < 256 and line( lPos // 1 ) not = " " do begin name( tPos // 1 ) := line( lPos // 1 ); lPos := lPos + 1; tPos := tPos + 1 end while_more_name ; % determine the node type % ndType := 1; resultNode := null; if name not = ";" then begin % not a null node % while ndType <= MAX_NODE_TYPE and name not = ndName( ndType ) do ndType := ndType + 1; if ndType > MAX_NODE_TYPE then rtError( "Malformed node." ); % handle the additional parameter for identifier/string/integer, or sub-nodes for operator nodes % if ndType = nInteger or ndType = nIdentifier or ndType = nString then begin while line( lPos // 1 ) = " " do lPos := lPos + 1; if ndType = nInteger then resultNode := operandNode( ndType, readInteger ) else if ndType = nIdentifier then resultNode := operandNode( ndType, readString( idList, " " ) ) else % ndType = nString % resultNode := operandNode( ndType, readString( stList, """" ) ) end else begin % operator node % reference(node) leftNode; leftNode := readNode; resultNode := opNode( ndType, leftNode, readNode ) end end if_non_null_node ; resultNode end readNode ; % interprets the specified node and returns the value % integer procedure eval ( reference(node) value n ) ; begin integer v; % prints a string from text, escape sequences are interpreted % procedure writeOnText( reference(textElement) value txHead; integer value txNumber ) ; begin reference(textElement) txPos; integer count; txPos := txHead; count := 1; while count < txNumber and txPos not = null do begin txPos := next(txPos); count := count + 1 end while_text_element_not_found ; if txPos = null then rtError( "INTERNAL ERROR: text not found." ) else begin % found the text - output it, handling escape sequences % integer cPos; cPos := 1; % start from 1 to skip over the leading " % while cPos < length(txPos) do begin string(1) ch; ch := text( start(txPos) + cPos ); if ch not = "\" then writeon( s_w := 0, ch ) else begin % escaped character % cPos := cPos + 1; if cPos > length(txPos) then rtError( "String terminates with ""\""." ) else begin ch := text( start(txPos) + cPos ); if ch = "n" then % newline % write() else writeon( s_w := 0, ch ) end end; cPos := cPos + 1 end while_not_end_of_string end end writeOnText ; % returns 1 if val is true, 0 otherwise % integer procedure booleanResult ( logical value val ) ; begin if val then 1 else 0 end booleanResult ; v := 0; if n = null then v := 0 else if type(n) = nIdentifier then v := data( iValue(n) ) else if type(n) = nString then v := iValue(n) else if type(n) = nInteger then v := iValue(n) else if type(n) = nSequence then begin % sequence - evaluate and discard the left branch and return the right branch % v := eval( left(n) ); v := eval( right(n) ) end else if type(n) = nIf then % if-else % begin if eval( left(n) ) not = 0 then v := eval( left(right(n)) ) else v := eval( right(right(n)) ); v := 0 end else if type(n) = nPrtc then % print character % writeon( s_w := 0, code( eval( left(n) ) ) ) else if type(n) = nPrts then % print string % writeOnText( stList, eval( left(n) ) ) else if type(n) = nPrti then % print integer % writeon( s_w := 0, i_w := 1, eval( left(n) ) ) else if type(n) = nWhile then % while-loop % begin while eval( left(n) ) not = 0 do v := eval( right(n) ); v := 0 end else if type(n) = nAssign then % assignment % data( iValue(left(n)) ) := eval( right(n) ) else if type(n) = nNegate then % unary - % v := - eval( left(n) ) else if type(n) = nNot then % unary not % v := booleanResult( eval( left(n) ) = 0 ) else if type(n) = nMultiply then % multiply % v := eval( left(n) ) * eval( right(n) ) else if type(n) = nDivide then % division % begin integer lv, rv; lv := eval( left(n) ); rv := eval( right(n) ); if rv = 0 then rtError( "Division by 0." ) else v := lv div rv end else if type(n) = nMod then % modulo % begin integer lv, rv; lv := eval( left(n) ); rv := eval( right(n) ); if rv = 0 then rtError( "Right operand of % is 0." ) else v := lv rem rv end else if type(n) = nAdd then % addition % v := eval( left(n) ) + eval( right(n) ) else if type(n) = nSubtract then % subtraction % v := eval( left(n) ) - eval( right(n) ) else if type(n) = nLess then % less-than % v := booleanResult( eval( left(n) ) < eval( right(n) ) ) else if type(n) = nLessEqual then % less or equal % v := booleanResult( eval( left(n) ) <= eval( right(n) ) ) else if type(n) = nGreater then % greater-than % v := booleanResult( eval( left(n) ) > eval( right(n) ) ) else if type(n) = nGreaterEqual then % greater or eq % v := booleanResult( eval( left(n) ) >= eval( right(n) ) ) else if type(n) = nEqual then % test equal % v := booleanResult( eval( left(n) ) = eval( right(n) ) ) else if type(n) = nNotEqual then % not-equal % v := booleanResult( eval( left(n) ) not = eval( right(n) ) ) else if type(n) = nAnd then % boolean "and" % begin v := eval( left(n) ); if v not = 0 then v := eval( right(n) ) end else if type(n) = nOr then % boolean "or" % begin v := eval( left(n) ); if v = 0 then v := eval( right(n) ); end else % unknown node % begin rtError( "Unknown node type in eval." ) end; v end eval ; nIdentifier := 1; ndName( nIdentifier ) := "Identifier"; nString := 2; ndName( nString ) := "String"; nInteger := 3; ndName( nInteger ) := "Integer"; nSequence := 4; ndName( nSequence ) := "Sequence"; nIf := 5; ndName( nIf ) := "If"; nPrtc := 6; ndName( nPrtc ) := "Prtc"; nPrts := 7; ndName( nPrts ) := "Prts"; nPrti := 8; ndName( nPrti ) := "Prti"; nWhile := 9; ndName( nWhile ) := "While"; nAssign := 10; ndName( nAssign ) := "Assign"; nNegate := 11; ndName( nNegate ) := "Negate"; nNot := 12; ndName( nNot ) := "Not"; nMultiply := 13; ndName( nMultiply ) := "Multiply"; nDivide := 14; ndName( nDivide ) := "Divide"; nMod := 15; ndName( nMod ) := "Mod"; nAdd := 16; ndName( nAdd ) := "Add"; nSubtract := 17; ndName( nSubtract ) := "Subtract"; nLess := 18; ndName( nLess ) := "Less"; nLessEqual := 19; ndName( nLessEqual ) := "LessEqual" ; nGreater := 20; ndName( nGreater ) := "Greater"; nGreaterEqual := 21; ndName( nGreaterEqual ) := "GreaterEqual"; nEqual := 22; ndName( nEqual ) := "Equal"; nNotEqual := 23; ndName( nNotEqual ) := "NotEqual"; nAnd := 24; ndName( nAnd ) := "And"; nOr := 25; ndName( nOr ) := "Or"; MAX_NODE_TYPE := 25; TEXT_MAX := 4095; textNext := 0; stList := idList := null; % parse the output from the syntax analyser and intetrpret parse tree % eval( readNode ) end.
http://rosettacode.org/wiki/Conway%27s_Game_of_Life	Conway's Game of Life	The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.	#ARM_Assembly	ARM Assembly	.string "PRG" lcd_ptr .req r4 active_fb .req r5 inactive_fb .req r6 offset_r .req r7 backup_fb .req r8 @ start push {r4-r10, r12, lr} ldr lcd_ptr, =0xC0000000 @ address of the LCD controller adr offset_r, offsets ldrh r0, [offset_r, #6] @ 0xffff is already in memory because -1 is in the offsets table str r0, [lcd_ptr, #0x200] @ set up paletted colors: 1 is black, 0 is white ldr r2, [lcd_ptr, #0x18] @ load lcd configuration bic r2, #14 orr r2, #6 @ Set color mode to 8 bpp, paletted str r2, [lcd_ptr, #0x18] ldr backup_fb, [lcd_ptr, #0x10] @ Save address of OS framebuffer @ allocate a buffer for game state / framebuffer ldr r0, =153600 @ 320 * 240 * 2 add r0, #8 svc #5 @ malloc push {r0} orr inactive_fb, r0, #7 add inactive_fb, #1 add active_fb, inactive_fb, #76800 @ fill buffer with random ones and zeroes ldr r10, =76800 mov r9, #0 1: subs r10, r10, #1 strb r9, [active_fb, r10] @ zero other framebuffer svc #206 @ rand syscall and r0, r0, #1 strb r0, [inactive_fb, r10] bne 1b @ set first and last rows to zero mov r2, #320 mov r1, #0 mov r0, inactive_fb push {r1,r2} svc #7 @ memset pop {r1,r2} ldr r3, =76480 add r0, r0, r3 svc #7 @ beginning of main loop, swap framebuffers 3: ldr r0, =76480 @ 320 * 239 str inactive_fb, [lcd_ptr, #0x10] mov inactive_fb, active_fb ldr active_fb, [lcd_ptr, #0x10] @ per-pixel loop 2: mov r1, #16 @ 8 * 2 mov r2, #0 sub r0, #1 @ loop to count up neighboring living cells 1: subs r1, #2 ldrsh r3, [offset_r, r1] @ cant use lsl #1 add r3, r3, r0 ldrb r3, [active_fb, r3] add r2, r2, r3 bne 1b @ at end of loop, r1 and r3 can be discarded @ decides whether the cell should live or die based on neighbors ldrb r1, [active_fb, r0] add r2, r2, r1 teq r2, #3 moveq r1, #1 teqne r2, #4 movne r1, #0 strb r1, [inactive_fb, r0] teq r0, #320 bne 2b @ checks if the escape key is pressed ldr r0, =0x900E001C ldr r1, [r0] tst r1, #0x80 beq 3b str backup_fb, [lcd_ptr, #0x10] @ restores OS framebuffer pop {r0} svc #6 @ free buffer pop {r4-r10, r12, pc} offsets: .hword -321, -320, -319, -1, 1, 319, 320, 321
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Maple	Maple	Point:= Record(x = 2,y = 4): Point:-x; Point:-y;
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Mathematica_.2F_Wolfram_Language	Mathematica / Wolfram Language	In[1]:= a = point[2, 3] Out[1]= point[2, 3] In[2]:= a[[2]] Out[2]= 3 In[3]:= a[[2]] = 4; a Out[3]= point[2, 4]
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Shiny	Shiny	src: 'hello' cpy: src
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Sidef	Sidef	var original = "hello"; # new String object var reference = original; # points at the original object var copy1 = String.new(original); # creates a new String object var copy2 = original+''; # ==//==
http://rosettacode.org/wiki/Constrained_random_points_on_a_circle	Constrained random points on a circle	Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.	#Python	Python	>>> from collections import defaultdict >>> from random import choice >>> world = defaultdict(int) >>> possiblepoints = [(x,y) for x in range(-15,16) for y in range(-15,16) if 10 <= abs(x+y*1j) <= 15] >>> for i in range(100): world[choice(possiblepoints)] += 1 >>> for x in range(-15,16): print(''.join(str(min([9, world[(x,y)]])) if world[(x,y)] else ' ' for y in range(-15,16))) 1 1 1 1 11 1 1 1 1 111 1 1211 1 2 1 1 11 1 11 21 1 1 11 1 1 2 1 1 1 2 1 1 1 1 1 2 11 1 1 1 1 1 1 2 1 1 1 1 1 2 1 1 3 11 2 11 1 1 1 2 1 1 2 1 1 1 1 1 2 2 1 1
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Raven	Raven	[ 'Enjoy' 'Rosetta' 'Code' ] as $words thread talker $words pop "%s\n" repeat dup print 500 choose ms talker as a talker as b talker as c
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Rhope	Rhope	Main(0,0) \|: Print["Enjoy"] Print["Rosetta"] Print["Code"] :\|
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Ruby	Ruby	%w{Enjoy Rosetta Code}.map do \|x\| Thread.new do sleep rand puts x end end.each do \|t\| t.join end
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Tcl	Tcl	proc makeFacExpr n { set exp 1 for {set i 2} {$i <= $n} {incr i} { append exp " * $i" } return "expr \{$exp\}" } eval [makeFacExpr 10]
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Ursala	Ursala	#import nat x = factorial 10 #executable& comcal = ! (%nP x)--<''>
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Visual_Basic_.NET	Visual Basic .NET	Module Program Const FACTORIAL_10 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 Sub Main() Console.WriteLine(FACTORIAL_10) End Sub End Module
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Wren	Wren	var factorial10 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 System.print(factorial10)
http://rosettacode.org/wiki/Conditional_structures	Conditional structures	Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.	#Aikido	Aikido	var x = loggedin ? sessionid : -1
http://rosettacode.org/wiki/Compiler/AST_interpreter	Compiler/AST interpreter	An AST interpreter interprets an Abstract Syntax Tree (AST) produced by a Syntax Analyzer. Task[edit] Take the AST output from the Syntax analyzer task, and interpret it as appropriate. Refer to the Syntax analyzer task for details of the AST. Loading the AST from the syntax analyzer is as simple as (pseudo code) def load_ast() line = readline() # Each line has at least one token line_list = tokenize the line, respecting double quotes text = line_list[0] # first token is always the node type if text == ";" # a terminal node return NULL node_type = text # could convert to internal form if desired # A line with two tokens is a leaf node # Leaf nodes are: Identifier, Integer, String # The 2nd token is the value if len(line_list) > 1 return make_leaf(node_type, line_list[1]) left = load_ast() right = load_ast() return make_node(node_type, left, right) The interpreter algorithm is relatively simple interp(x) if x == NULL return NULL elif x.node_type == Integer return x.value converted to an integer elif x.node_type == Ident return the current value of variable x.value elif x.node_type == String return x.value elif x.node_type == Assign globals[x.left.value] = interp(x.right) return NULL elif x.node_type is a binary operator return interp(x.left) operator interp(x.right) elif x.node_type is a unary operator, return return operator interp(x.left) elif x.node_type == If if (interp(x.left)) then interp(x.right.left) else interp(x.right.right) return NULL elif x.node_type == While while (interp(x.left)) do interp(x.right) return NULL elif x.node_type == Prtc print interp(x.left) as a character, no newline return NULL elif x.node_type == Prti print interp(x.left) as an integer, no newline return NULL elif x.node_type == Prts print interp(x.left) as a string, respecting newlines ("\n") return NULL elif x.node_type == Sequence interp(x.left) interp(x.right) return NULL else error("unknown node type") Notes: Because of the simple nature of our tiny language, Semantic analysis is not needed. Your interpreter should use C like division semantics, for both division and modulus. For division of positive operands, only the non-fractional portion of the result should be returned. In other words, the result should be truncated towards 0. This means, for instance, that 3 / 2 should result in 1. For division when one of the operands is negative, the result should be truncated towards 0. This means, for instance, that 3 / -2 should result in -1. Test program prime.t lex <prime.t \| parse \| interp /* Simple prime number generator / count = 1; n = 1; limit = 100; while (n < limit) { k=3; p=1; n=n+2; while ((kk<=n) && (p)) { p=n/k*k!=n; k=k+2; } if (p) { print(n, " is prime\n"); count = count + 1; } } print("Total primes found: ", count, "\n"); 3 is prime 5 is prime 7 is prime 11 is prime 13 is prime 17 is prime 19 is prime 23 is prime 29 is prime 31 is prime 37 is prime 41 is prime 43 is prime 47 is prime 53 is prime 59 is prime 61 is prime 67 is prime 71 is prime 73 is prime 79 is prime 83 is prime 89 is prime 97 is prime 101 is prime Total primes found: 26 Additional examples Your solution should pass all the test cases above and the additional tests found Here. Reference The C and Python versions can be considered reference implementations. Related Tasks Lexical Analyzer task Syntax Analyzer task Code Generator task Virtual Machine Interpreter task	#C	C	#include <stdlib.h> #include <stdio.h> #include <string.h> #include <stdarg.h> #include <ctype.h> #define da_dim(name, type) type name = NULL; \ int _qy_ ## name ## _p = 0; \ int _qy_ ## name ## _max = 0 #define da_rewind(name) _qy_ ## name ## _p = 0 #define da_redim(name) do {if (_qy_ ## name ## _p >= _qy_ ## name ## _max) \ name = realloc(name, (_qy_ ## name ## _max += 32) sizeof(name[0]));} while (0) #define da_append(name, x) do {da_redim(name); name[_qy_ ## name ## _p++] = x;} while (0) #define da_len(name) _qy_ ## name ## _p #define da_add(name) do {da_redim(name); _qy_ ## name ## _p++;} while (0) typedef enum { nd_Ident, nd_String, nd_Integer, nd_Sequence, nd_If, nd_Prtc, nd_Prts, nd_Prti, nd_While, nd_Assign, nd_Negate, nd_Not, nd_Mul, nd_Div, nd_Mod, nd_Add, nd_Sub, nd_Lss, nd_Leq, nd_Gtr, nd_Geq, nd_Eql, nd_Neq, nd_And, nd_Or } NodeType; typedef struct Tree Tree; struct Tree { NodeType node_type; Tree left; Tree right; int value; }; // dependency: Ordered by NodeType, must remain in same order as NodeType enum struct { char enum_text; NodeType node_type; } atr[] = { {"Identifier" , nd_Ident, }, {"String" , nd_String, }, {"Integer" , nd_Integer,}, {"Sequence" , nd_Sequence,}, {"If" , nd_If, }, {"Prtc" , nd_Prtc, }, {"Prts" , nd_Prts, }, {"Prti" , nd_Prti, }, {"While" , nd_While, }, {"Assign" , nd_Assign, }, {"Negate" , nd_Negate, }, {"Not" , nd_Not, }, {"Multiply" , nd_Mul, }, {"Divide" , nd_Div, }, {"Mod" , nd_Mod, }, {"Add" , nd_Add, }, {"Subtract" , nd_Sub, }, {"Less" , nd_Lss, }, {"LessEqual" , nd_Leq, }, {"Greater" , nd_Gtr, }, {"GreaterEqual", nd_Geq, }, {"Equal" , nd_Eql, }, {"NotEqual" , nd_Neq, }, {"And" , nd_And, }, {"Or" , nd_Or, }, }; FILE source_fp; da_dim(string_pool, const char ); da_dim(global_names, const char ); da_dim(global_values, int); void error(const char fmt, ... ) { va_list ap; char buf[1000]; va_start(ap, fmt); vsprintf(buf, fmt, ap); printf("error: %s\n", buf); exit(1); } Tree make_node(NodeType node_type, Tree left, Tree right) { Tree t = calloc(sizeof(Tree), 1); t->node_type = node_type; t->left = left; t->right = right; return t; } Tree make_leaf(NodeType node_type, int value) { Tree t = calloc(sizeof(Tree), 1); t->node_type = node_type; t->value = value; return t; } int interp(Tree x) { /* interpret the parse tree / if (!x) return 0; switch(x->node_type) { case nd_Integer: return x->value; case nd_Ident: return global_values[x->value]; case nd_String: return x->value; case nd_Assign: return global_values[x->left->value] = interp(x->right); case nd_Add: return interp(x->left) + interp(x->right); case nd_Sub: return interp(x->left) - interp(x->right); case nd_Mul: return interp(x->left) interp(x->right); case nd_Div: return interp(x->left) / interp(x->right); case nd_Mod: return interp(x->left) % interp(x->right); case nd_Lss: return interp(x->left) < interp(x->right); case nd_Gtr: return interp(x->left) > interp(x->right); case nd_Leq: return interp(x->left) <= interp(x->right); case nd_Eql: return interp(x->left) == interp(x->right); case nd_Neq: return interp(x->left) != interp(x->right); case nd_And: return interp(x->left) && interp(x->right); case nd_Or: return interp(x->left) \|\| interp(x->right); case nd_Negate: return -interp(x->left); case nd_Not: return !interp(x->left); case nd_If: if (interp(x->left)) interp(x->right->left); else interp(x->right->right); return 0; case nd_While: while (interp(x->left)) interp(x->right); return 0; case nd_Prtc: printf("%c", interp(x->left)); return 0; case nd_Prti: printf("%d", interp(x->left)); return 0; case nd_Prts: printf("%s", string_pool[interp(x->left)]); return 0; case nd_Sequence: interp(x->left); interp(x->right); return 0; default: error("interp: unknown tree type %d\n", x->node_type); } return 0; } void init_in(const char fn[]) { if (fn[0] == '\0') source_fp = stdin; else { source_fp = fopen(fn, "r"); if (source_fp == NULL) error("Can't open %s\n", fn); } } NodeType get_enum_value(const char name[]) { for (size_t i = 0; i < sizeof(atr) / sizeof(atr[0]); i++) { if (strcmp(atr[i].enum_text, name) == 0) { return atr[i].node_type; } } error("Unknown token %s\n", name); return -1; } char read_line(int len) { static char text = NULL; static int textmax = 0; for (len = 0; ; (len)++) { int ch = fgetc(source_fp); if (ch == EOF \|\| ch == '\n') { if (len == 0) return NULL; break; } if (len + 1 >= textmax) { textmax = (textmax == 0 ? 128 : textmax 2); text = realloc(text, textmax); } text[len] = ch; } text[len] = '\0'; return text; } char rtrim(char text, int len) { // remove trailing spaces for (; len > 0 && isspace(text[len - 1]); --(len)) ; text[len] = '\0'; return text; } int fetch_string_offset(char st) { int len = strlen(st); st[len - 1] = '\0'; ++st; char p, q; p = q = st; while ((p++ = q++) != '\0') { if (q[-1] == '\\') { if (q[0] == 'n') { p[-1] = '\n'; ++q; } else if (q[0] == '\\') { ++q; } } } for (int i = 0; i < da_len(string_pool); ++i) { if (strcmp(st, string_pool[i]) == 0) { return i; } } da_add(string_pool); int n = da_len(string_pool) - 1; string_pool[n] = strdup(st); return da_len(string_pool) - 1; } int fetch_var_offset(const char name) { for (int i = 0; i < da_len(global_names); ++i) { if (strcmp(name, global_names[i]) == 0) return i; } da_add(global_names); int n = da_len(global_names) - 1; global_names[n] = strdup(name); da_append(global_values, 0); return n; } Tree load_ast() { int len; char yytext = read_line(&len); yytext = rtrim(yytext, &len); // get first token char tok = strtok(yytext, " "); if (tok[0] == ';') { return NULL; } NodeType node_type = get_enum_value(tok); // if there is extra data, get it char p = tok + strlen(tok); if (p != &yytext[len]) { int n; for (++p; isspace(p); ++p) ; switch (node_type) { case nd_Ident: n = fetch_var_offset(p); break; case nd_Integer: n = strtol(p, NULL, 0); break; case nd_String: n = fetch_string_offset(p); break; default: error("Unknown node type: %s\n", p); } return make_leaf(node_type, n); } Tree left = load_ast(); Tree right = load_ast(); return make_node(node_type, left, right); } int main(int argc, char argv[]) { init_in(argc > 1 ? argv[1] : ""); Tree x = load_ast(); interp(x); return 0; }
http://rosettacode.org/wiki/Compiler/syntax_analyzer	Compiler/syntax analyzer	A Syntax analyzer transforms a token stream (from the Lexical analyzer) into a Syntax tree, based on a grammar. Task[edit] Take the output from the Lexical analyzer task, and convert it to an Abstract Syntax Tree (AST), based on the grammar below. The output should be in a flattened format. The program should read input from a file and/or stdin, and write output to a file and/or stdout. If the language being used has a parser module/library/class, it would be great if two versions of the solution are provided: One without the parser module, and one with. Grammar The simple programming language to be analyzed is more or less a (very tiny) subset of C. The formal grammar in Extended Backus-Naur Form (EBNF): stmt_list = {stmt} ; stmt = ';' \| Identifier '=' expr ';' \| 'while' paren_expr stmt \| 'if' paren_expr stmt ['else' stmt] \| 'print' '(' prt_list ')' ';' \| 'putc' paren_expr ';' \| '{' stmt_list '}' ; paren_expr = '(' expr ')' ; prt_list = (string \| expr) {',' (String \| expr)} ; expr = and_expr {'\|\|' and_expr} ; and_expr = equality_expr {'&&' equality_expr} ; equality_expr = relational_expr [('==' \| '!=') relational_expr] ; relational_expr = addition_expr [('<' \| '<=' \| '>' \| '>=') addition_expr] ; addition_expr = multiplication_expr {('+' \| '-') multiplication_expr} ; multiplication_expr = primary {('' \| '/' \| '%') primary } ; primary = Identifier \| Integer \| '(' expr ')' \| ('+' \| '-' \| '!') primary ; The resulting AST should be formulated as a Binary Tree. Example - given the simple program (below), stored in a file called while.t, create the list of tokens, using one of the Lexical analyzer solutions lex < while.t > while.lex Run one of the Syntax analyzer solutions parse < while.lex > while.ast The following table shows the input to lex, lex output, and the AST produced by the parser Input to lex Output from lex, input to parse Output from parse count = 1; while (count < 10) { print("count is: ", count, "\n"); count = count + 1; } 1 1 Identifier count 1 7 Op_assign 1 9 Integer 1 1 10 Semicolon 2 1 Keyword_while 2 7 LeftParen 2 8 Identifier count 2 14 Op_less 2 16 Integer 10 2 18 RightParen 2 20 LeftBrace 3 5 Keyword_print 3 10 LeftParen 3 11 String "count is: " 3 23 Comma 3 25 Identifier count 3 30 Comma 3 32 String "\n" 3 36 RightParen 3 37 Semicolon 4 5 Identifier count 4 11 Op_assign 4 13 Identifier count 4 19 Op_add 4 21 Integer 1 4 22 Semicolon 5 1 RightBrace 6 1 End_of_input Sequence Sequence ; Assign Identifier count Integer 1 While Less Identifier count Integer 10 Sequence Sequence ; Sequence Sequence Sequence ; Prts String "count is: " ; Prti Identifier count ; Prts String "\n" ; Assign Identifier count Add Identifier count Integer 1 Specifications List of node type names Identifier String Integer Sequence If Prtc Prts Prti While Assign Negate Not Multiply Divide Mod Add Subtract Less LessEqual Greater GreaterEqual Equal NotEqual And Or In the text below, Null/Empty nodes are represented by ";". Non-terminal (internal) nodes For Operators, the following nodes should be created: Multiply Divide Mod Add Subtract Less LessEqual Greater GreaterEqual Equal NotEqual And Or For each of the above nodes, the left and right sub-nodes are the operands of the respective operation. In pseudo S-Expression format: (Operator expression expression) Negate, Not For these node types, the left node is the operand, and the right node is null. (Operator expression ;) Sequence - sub-nodes are either statements or Sequences. If - left node is the expression, the right node is If node, with it's left node being the if-true statement part, and the right node being the if-false (else) statement part. (If expression (If statement else-statement)) If there is not an else, the tree becomes: (If expression (If statement ;)) Prtc (Prtc (expression) ;) Prts (Prts (String "the string") ;) Prti (Prti (Integer 12345) ;) While - left node is the expression, the right node is the statement. (While expression statement) Assign - left node is the left-hand side of the assignment, the right node is the right-hand side of the assignment. (Assign Identifier expression) Terminal (leaf) nodes: Identifier: (Identifier ident_name) Integer: (Integer 12345) String: (String "Hello World!") ";": Empty node Some simple examples Sequences denote a list node; they are used to represent a list. semicolon's represent a null node, e.g., the end of this path. This simple program: a=11; Produces the following AST, encoded as a binary tree: Under each non-leaf node are two '\|' lines. The first represents the left sub-node, the second represents the right sub-node: (1) Sequence (2) \|-- ; (3) \|-- Assign (4) \|-- Identifier: a (5) \|-- Integer: 11 In flattened form: (1) Sequence (2) ; (3) Assign (4) Identifier a (5) Integer 11 This program: a=11; b=22; c=33; Produces the following AST: ( 1) Sequence ( 2) \|-- Sequence ( 3) \| \|-- Sequence ( 4) \| \| \|-- ; ( 5) \| \| \|-- Assign ( 6) \| \| \|-- Identifier: a ( 7) \| \| \|-- Integer: 11 ( 8) \| \|-- Assign ( 9) \| \|-- Identifier: b (10) \| \|-- Integer: 22 (11) \|-- Assign (12) \|-- Identifier: c (13) \|-- Integer: 33 In flattened form: ( 1) Sequence ( 2) Sequence ( 3) Sequence ( 4) ; ( 5) Assign ( 6) Identifier a ( 7) Integer 11 ( 8) Assign ( 9) Identifier b (10) Integer 22 (11) Assign (12) Identifier c (13) Integer 33 Pseudo-code for the parser. Uses Precedence Climbing for expression parsing, and Recursive Descent for statement parsing. The AST is also built: def expr(p) if tok is "(" x = paren_expr() elif tok in ["-", "+", "!"] gettok() y = expr(precedence of operator) if operator was "+" x = y else x = make_node(operator, y) elif tok is an Identifier x = make_leaf(Identifier, variable name) gettok() elif tok is an Integer constant x = make_leaf(Integer, integer value) gettok() else error() while tok is a binary operator and precedence of tok >= p save_tok = tok gettok() q = precedence of save_tok if save_tok is not right associative q += 1 x = make_node(Operator save_tok represents, x, expr(q)) return x def paren_expr() expect("(") x = expr(0) expect(")") return x def stmt() t = NULL if accept("if") e = paren_expr() s = stmt() t = make_node(If, e, make_node(If, s, accept("else") ? stmt() : NULL)) elif accept("putc") t = make_node(Prtc, paren_expr()) expect(";") elif accept("print") expect("(") repeat if tok is a string e = make_node(Prts, make_leaf(String, the string)) gettok() else e = make_node(Prti, expr(0)) t = make_node(Sequence, t, e) until not accept(",") expect(")") expect(";") elif tok is ";" gettok() elif tok is an Identifier v = make_leaf(Identifier, variable name) gettok() expect("=") t = make_node(Assign, v, expr(0)) expect(";") elif accept("while") e = paren_expr() t = make_node(While, e, stmt() elif accept("{") while tok not equal "}" and tok not equal end-of-file t = make_node(Sequence, t, stmt()) expect("}") elif tok is end-of-file pass else error() return t def parse() t = NULL gettok() repeat t = make_node(Sequence, t, stmt()) until tok is end-of-file return t Once the AST is built, it should be output in a flattened format. This can be as simple as the following def prt_ast(t) if t == NULL print(";\n") else print(t.node_type) if t.node_type in [Identifier, Integer, String] # leaf node print the value of the Ident, Integer or String, "\n" else print("\n") prt_ast(t.left) prt_ast(t.right) If the AST is correctly built, loading it into a subsequent program should be as simple as def load_ast() line = readline() # Each line has at least one token line_list = tokenize the line, respecting double quotes text = line_list[0] # first token is always the node type if text == ";" # a terminal node return NULL node_type = text # could convert to internal form if desired # A line with two tokens is a leaf node # Leaf nodes are: Identifier, Integer, String # The 2nd token is the value if len(line_list) > 1 return make_leaf(node_type, line_list[1]) left = load_ast() right = load_ast() return make_node(node_type, left, right) Finally, the AST can also be tested by running it against one of the AST Interpreter solutions. Test program, assuming this is in a file called prime.t lex <prime.t \| parse Input to lex Output from lex, input to parse Output from parse / Simple prime number generator / count = 1; n = 1; limit = 100; while (n < limit) { k=3; p=1; n=n+2; while ((kk<=n) && (p)) { p=n/k*k!=n; k=k+2; } if (p) { print(n, " is prime\n"); count = count + 1; } } print("Total primes found: ", count, "\n"); 4 1 Identifier count 4 7 Op_assign 4 9 Integer 1 4 10 Semicolon 5 1 Identifier n 5 3 Op_assign 5 5 Integer 1 5 6 Semicolon 6 1 Identifier limit 6 7 Op_assign 6 9 Integer 100 6 12 Semicolon 7 1 Keyword_while 7 7 LeftParen 7 8 Identifier n 7 10 Op_less 7 12 Identifier limit 7 17 RightParen 7 19 LeftBrace 8 5 Identifier k 8 6 Op_assign 8 7 Integer 3 8 8 Semicolon 9 5 Identifier p 9 6 Op_assign 9 7 Integer 1 9 8 Semicolon 10 5 Identifier n 10 6 Op_assign 10 7 Identifier n 10 8 Op_add 10 9 Integer 2 10 10 Semicolon 11 5 Keyword_while 11 11 LeftParen 11 12 LeftParen 11 13 Identifier k 11 14 Op_multiply 11 15 Identifier k 11 16 Op_lessequal 11 18 Identifier n 11 19 RightParen 11 21 Op_and 11 24 LeftParen 11 25 Identifier p 11 26 RightParen 11 27 RightParen 11 29 LeftBrace 12 9 Identifier p 12 10 Op_assign 12 11 Identifier n 12 12 Op_divide 12 13 Identifier k 12 14 Op_multiply 12 15 Identifier k 12 16 Op_notequal 12 18 Identifier n 12 19 Semicolon 13 9 Identifier k 13 10 Op_assign 13 11 Identifier k 13 12 Op_add 13 13 Integer 2 13 14 Semicolon 14 5 RightBrace 15 5 Keyword_if 15 8 LeftParen 15 9 Identifier p 15 10 RightParen 15 12 LeftBrace 16 9 Keyword_print 16 14 LeftParen 16 15 Identifier n 16 16 Comma 16 18 String " is prime\n" 16 31 RightParen 16 32 Semicolon 17 9 Identifier count 17 15 Op_assign 17 17 Identifier count 17 23 Op_add 17 25 Integer 1 17 26 Semicolon 18 5 RightBrace 19 1 RightBrace 20 1 Keyword_print 20 6 LeftParen 20 7 String "Total primes found: " 20 29 Comma 20 31 Identifier count 20 36 Comma 20 38 String "\n" 20 42 RightParen 20 43 Semicolon 21 1 End_of_input Sequence Sequence Sequence Sequence Sequence ; Assign Identifier count Integer 1 Assign Identifier n Integer 1 Assign Identifier limit Integer 100 While Less Identifier n Identifier limit Sequence Sequence Sequence Sequence Sequence ; Assign Identifier k Integer 3 Assign Identifier p Integer 1 Assign Identifier n Add Identifier n Integer 2 While And LessEqual Multiply Identifier k Identifier k Identifier n Identifier p Sequence Sequence ; Assign Identifier p NotEqual Multiply Divide Identifier n Identifier k Identifier k Identifier n Assign Identifier k Add Identifier k Integer 2 If Identifier p If Sequence Sequence ; Sequence Sequence ; Prti Identifier n ; Prts String " is prime\n" ; Assign Identifier count Add Identifier count Integer 1 ; Sequence Sequence Sequence ; Prts String "Total primes found: " ; Prti Identifier count ; Prts String "\n" ; Additional examples Your solution should pass all the test cases above and the additional tests found Here. Reference The C and Python versions can be considered reference implementations. Related Tasks Lexical Analyzer task Code Generator task Virtual Machine Interpreter task AST Interpreter task	#ALGOL_W	ALGOL W	begin % syntax analyser % % parse tree nodes % record node( integer type ; reference(node) left, right ; integer iValue % nString/nIndentifier number or nInteger value % ); integer nIdentifier, nString, nInteger, nSequence, nIf, nPrtc, nPrts , nPrti, nWhile, nAssign, nNegate, nNot, nMultiply , nDivide, nMod, nAdd, nSubtract, nLess, nLessEqual , nGreater, nGreaterEqual, nEqual, nNotEqual, nAnd, nOr ; string(14) array ndName ( 1 :: 25 ); % tokens - names must match those output by the lexical analyser % integer tkType, tkLine, tkColumn, tkLength, tkIntegerValue; integer tOp_multiply , tOp_divide , tOp_mod , tOp_add , tOp_subtract , tOp_negate , tOp_less , tOp_lessequal , tOp_greater , tOp_greaterequal , tOp_equal , tOp_notequal , tOp_not , tOp_assign , tOp_and , tOp_or , tLeftParen , tRightParen , tLeftBrace , tRightBrace , tSemicolon , tComma , tKeyword_if , tKeyword_else , tKeyword_while , tKeyword_print , tKeyword_putc , tIdentifier , tInteger , tString , tEnd_of_input , MAX_TOKEN_TYPE, PRIMARY_PREC ; string(16) array tkName ( 1 :: 31 ); integer array tkPrec, tkNode ( 1 :: 31 ); % string literals and identifiers - uses a linked list - a hash table might be better... % string(1) array text ( 0 :: 4095 ); integer textNext, TEXT_MAX; record textElement ( integer start, length; reference(textElement) next ); reference(textElement) idList, stList; % returns a new node with left and right branches % reference(node) procedure opNode ( integer value opType; reference(node) value opLeft, opRight ) ; begin node( opType, opLeft, opRight, 0 ) end opNode ; % returns a new operand node % reference(node) procedure operandNode ( integer value opType, opValue ) ; begin node( opType, null, null, opValue ) end operandNode ; % reports an error % procedure synError( integer value line, column; string(80) value message ); begin integer errorPos; write( i_w := 1, s_w := 0, "**** Error at(", line, ",", column, "): " ); errorPos := 0; while errorPos < 80 and message( errorPos // 1 ) not = "." do begin writeon( s_w := 0, message( errorPos // 1 ) ); errorPos := errorPos + 1 end while_not_at_end_of_message ; writeon( s_w := 0, "." ) end synError ; % reports an error and stops % procedure fatalError( integer value line, column; string(80) value message ); begin synError( line, column, message ); assert( false ) end fatalError ; % prints a node and its sub-nodes % procedure writeNode( reference(node) value n ) ; begin % prints an identifier or string from text % procedure writeOnText( reference(textElement) value txHead; integer value txNumber ) ; begin reference(textElement) txPos; integer count; txPos := txHead; count := 1; while count < txNumber and txPos not = null do begin txPos := next(txPos); count := count + 1 end while_text_element_not_found ; if txPos = null then fatalError( 0, txNumber, "INTERNAL ERROR: text not found." ) else for cPos := 0 until length(txPos) - 1 do writeon( text( start(txPos) + cPos ) ); if text( start(txPos) ) = """" then writeon( """" ); end writeOnText ; if n = null then write( ";" ) else begin write( ndName( type(n) ) ); if type(n) = nInteger then writeon( iValue(n) ) else if type(n) = nIdentifier then writeOnText( idList, iValue(n) ) else if type(n) = nString then writeOnText( stList, iValue(n) ) else begin writeNode( left(n) ); writeNode( right(n) ) end end end writeNode ; % reads a token from standard input % procedure readToken ; begin % parses a string from line and stores it in a string in the text array % % - if it is not already present in the specified textElement list. % % returns the position of the string in the text array % integer procedure readString ( reference(textElement) value result txList; string(1) value terminator ) ; begin string(256) str; integer sLen, sPos, ePos; logical found; reference(textElement) txPos, txLastPos; % get the text of the string % str := " "; sLen := 0; str( sLen // 1 ) := line( lPos // 1 ); sLen := sLen + 1; lPos := lPos + 1; while lPos <= 255 and line( lPos // 1 ) not = terminator do begin str( sLen // 1 ) := line( lPos // 1 ); sLen := sLen + 1; lPos := lPos + 1 end while_more_string ; if lPos > 255 then fatalError( tkLine, tkColumn, "Unterminated String in token file." ); % attempt to find the text in the list of strings/identifiers % txLastPos := txPos := txList; found := false; ePos := 0; while not found and txPos not = null do begin ePos := ePos + 1; found := ( length(txPos) = sLen ); sPos := 0; while found and sPos < sLen do begin found := str( sPos // 1 ) = text( start(txPos) + sPos ); sPos := sPos + 1 end while_not_found ; txLastPos := txPos; if not found then txPos := next(txPos) end while_string_not_found ; if not found then begin % the string/identifier is not in the list - add it % ePos := ePos + 1; if txList = null then txList := textElement( textNext, sLen, null ) else next(txLastPos) := textElement( textNext, sLen, null ); if textNext + sLen > TEXT_MAX then fatalError( tkLine, tkColumn, "Text space exhausted." ) else begin for cPos := 0 until sLen - 1 do begin text( textNext ) := str( cPos // 1 ); textNext := textNext + 1 end for_cPos end end if_not_found ; ePos end readString ; % gets an integer from the line - no checks for valid digits % integer procedure readInteger ; begin integer n; while line( lPos // 1 ) = " " do lPos := lPos + 1; n := 0; while line( lPos // 1 ) not = " " do begin n := ( n * 10 ) + ( decode( line( lPos // 1 ) ) - decode( "0" ) ); lPos := lPos + 1 end while_not_end_of_integer ; n end readInteger ; string(256) line; string(16) name; integer lPos, tPos; tPos := lPos := 0; readcard( line ); % get the line and column numbers % tkLine := readInteger; tkColumn := readInteger; % get the token name % while line( lPos // 1 ) = " " do lPos := lPos + 1; name := ""; while lPos < 256 and line( lPos // 1 ) not = " " do begin name( tPos // 1 ) := line( lPos // 1 ); lPos := lPos + 1; tPos := tPos + 1 end while_more_name ; % determine the token type % tkType := 1; tkIntegerValue := 0; while tkType <= MAX_TOKEN_TYPE and name not = tkName( tkType ) do tkType := tkType + 1; if tkType > MAX_TOKEN_TYPE then fatalError( tkLine, tkColumn, "Malformed token" ); % handle the additional parameter for identifier/string/integer % if tkType = tInteger or tkType = tIdentifier or tkType = tString then begin while line( lPos // 1 ) = " " do lPos := lPos + 1; if tkType = tInteger then tkIntegerValue := readInteger else if tkType = tIdentifier then tkIntegerValue := readString( idList, " " ) else % tkType = tString % tkIntegerValue := readString( stList, """" ) end if_token_with_additional_parameter ; end readToken ; % parses a statement % reference(node) procedure parseStatement ; begin reference(node) stmtNode, stmtExpr; % skips the current token if it is expectedToken, % % returns true if the token was expectedToken, false otherwise % logical procedure have ( integer value expectedToken ) ; begin logical haveExpectedToken; haveExpectedToken := ( tkType = expectedToken ); if haveExpectedToken and tkType not = tEnd_of_input then readToken; haveExpectedToken end have ; % issues an error message and skips past the next semi-colon or to end of input % procedure skipStatement ( string(80) value message ) ; begin synError( tkLine, tkColumn, message ); while tkType not = tEnd_of_input and not have( tSemicolon ) do readToken end skipStatement ; % checks we have a semicolon, issues an error and skips the statement if not % procedure mustBeEndOfStatement ; begin if not have( tSemicolon ) then skipStatement( """;"" expected." ) end mustBeEndOfStatement ; % skips the current token if it is "(" and issues an error if it isn't % procedure mustBeLeftParen ; begin if not have( tLeftParen ) then synError( tkLine, tkColumn, """("" expected." ) end % mustBeLeftParen % ; % skips the current token if it is ")" and issues an error if it isn't % procedure mustBeRightParen ; begin if not have( tRightParen ) then synError( tkLine, tkColumn, """)"" expected." ) end % mustBeRightParen % ; % gets the next token and parses an expression with the specified precedence % reference(node) procedure nextAndparseExpr ( integer value precedence ) ; begin readToken; parseExpr( precedence ) end nextAndParseExpr ; % parses an expression with the specified precedence % % all operators are assumed to be left-associative % reference(node) procedure parseExpr ( integer value precedence ) ; begin % handles a single token primary % reference(node) procedure simplePrimary ( integer value primaryNodeType ) ; begin reference(node) primaryNode; primaryNode := operandNode( primaryNodeType, tkIntegerValue ); readToken; primaryNode end simplePrimary ; reference(node) exprNode; if precedence < PRIMARY_PREC then begin exprNode := parseExpr( precedence + 1 ); while tkPrec( tkType ) = precedence do begin integer op; op := tkNode( tkType ); exprNode := opNode( op, exprNode, nextAndParseExpr( precedence + 1 ) ) end while_op_at_this_precedence_level end else if tkType = tIdentifier then exprNode := simplePrimary( nIdentifier ) else if tkType = tInteger then exprNode := simplePrimary( nInteger ) else if tkType = nString then begin synError( tkLine, tkColumn, "Unexpected string literal." ); exprNode := simplePrimary( nInteger ) end else if tkType = tLeftParen then exprNode := parseParenExpr else if tkType = tOp_add then exprNode := nextAndParseExpr( precedence ) else if tkType = tOp_subtract then exprNode := opNode( nNegate, nextAndParseExpr( precedence ), null ) else if tkType = tOp_not then exprNode := opNode( nNot, nextAndParseExpr( precedence ), null ) else begin synError( tkLine, tkColumn, "Syntax error in expression." ); exprNode := simplePrimary( nInteger ) end; exprNode end parseExpr ; % parses a preenthesised expression % reference(node) procedure parseParenExpr ; begin reference(node) exprNode; mustBeLeftParen; exprNode := parseExpr( 0 ); mustBeRightParen; exprNode end parseParenExpr ; % parse statement depending on it's first token % if tkType = tIdentifier then begin % assignment statement % stmtExpr := operandNode( nIdentifier, tkIntegerValue ); % skip the identifier and check for "=" % readToken; if not have( tOp_Assign ) then synError( tkLine, tkColumn, "Expected ""="" in assignment statement." ); stmtNode := opNode( nAssign, stmtExpr, parseExpr( 0 ) ); mustBeEndOfStatement end else if have( tKeyword_while ) then begin stmtExpr := parseParenExpr; stmtNode := opNode( nWhile, stmtExpr, parseStatement ) end else if have( tkeyword_if ) then begin stmtExpr := parseParenExpr; stmtNode := opNode( nIf, stmtExpr, opNode( nIf, parseStatement, null ) ); if have( tKeyword_else ) then % have an "else" part % right(right(stmtNode)) := parseStatement end else if have( tKeyword_Print ) then begin mustBeLeftParen; stmtNode := null; while begin if tkType = tString then begin stmtNode := opNode( nSequence, stmtNode, opNode( nPrts, operandNode( nString, tkIntegerValue ), null ) ); readToken end else stmtNode := opNode( nSequence, stmtNode, opNode( nPrti, parseExpr( 0 ), null ) ); have( tComma ) end do begin end; mustBeRightparen; mustBeEndOfStatement; end else if have( tKeyword_Putc ) then begin stmtNode := opNode( nPrtc, parseParenExpr, null ); mustBeEndOfStatement end else if have( tLeftBrace ) then begin % block % stmtNode := parseStatementList( tRightBrace ); if not have( tRightBrace ) then synError( tkLine, tkColumn, "Expected ""}""." ); end else if have( tSemicolon ) then stmtNode := null else begin % unrecognised statement % skipStatement( "Unrecognised statement." ); stmtNode := null end if_various_tokens ; stmtNode end parseStatement ; % parses a statement list ending with the specified terminator % reference(node) procedure parseStatementList ( integer value terminator ) ; begin reference(node) listNode; listNode := null; while tkType not = terminator and tkType not = tEnd_of_input do listNode := opNode( nSequence, listNode, parseStatement ); listNode end parseStatementList ; nIdentifier := 1; ndName( nIdentifier ) := "Identifier"; nString := 2; ndName( nString ) := "String"; nInteger := 3; ndName( nInteger ) := "Integer"; nSequence := 4; ndName( nSequence ) := "Sequence"; nIf := 5; ndName( nIf ) := "If"; nPrtc := 6; ndName( nPrtc ) := "Prtc"; nPrts := 7; ndName( nPrts ) := "Prts"; nPrti := 8; ndName( nPrti ) := "Prti"; nWhile := 9; ndName( nWhile ) := "While"; nAssign := 10; ndName( nAssign ) := "Assign"; nNegate := 11; ndName( nNegate ) := "Negate"; nNot := 12; ndName( nNot ) := "Not"; nMultiply := 13; ndName( nMultiply ) := "Multiply"; nDivide := 14; ndName( nDivide ) := "Divide"; nMod := 15; ndName( nMod ) := "Mod"; nAdd := 16; ndName( nAdd ) := "Add"; nSubtract := 17; ndName( nSubtract ) := "Subtract"; nLess := 18; ndName( nLess ) := "Less"; nLessEqual := 19; ndName( nLessEqual ) := "LessEqual" ; nGreater := 20; ndName( nGreater ) := "Greater"; nGreaterEqual := 21; ndName( nGreaterEqual ) := "GreaterEqual"; nEqual := 22; ndName( nEqual ) := "Equal"; nNotEqual := 23; ndName( nNotEqual ) := "NotEqual"; nAnd := 24; ndName( nAnd ) := "And"; nOr := 25; ndName( nOr ) := "Or"; tOp_multiply := 1; tkName( tOp_multiply ) := "Op_multiply"; tkPrec( tOp_multiply ) := 5; tOp_divide := 2; tkName( tOp_divide ) := "Op_divide"; tkPrec( tOp_divide ) := 5; tOp_mod := 3; tkName( tOp_mod ) := "Op_mod"; tkPrec( tOp_mod ) := 5; tOp_add := 4; tkName( tOp_add ) := "Op_add"; tkPrec( tOp_add ) := 4; tOp_subtract := 5; tkName( tOp_subtract ) := "Op_subtract"; tkPrec( tOp_subtract ) := 4; tOp_negate := 6; tkName( tOp_negate ) := "Op_negate"; tkPrec( tOp_negate ) := -1; tOp_less := 7; tkName( tOp_less ) := "Op_less"; tkPrec( tOp_less ) := 3; tOp_lessequal := 8; tkName( tOp_lessequal ) := "Op_lessequal"; tkPrec( tOp_lessequal ) := 3; tOp_greater := 9; tkName( tOp_greater ) := "Op_greater"; tkPrec( tOp_greater ) := 3; tOp_greaterequal := 10; tkName( tOp_greaterequal ) := "Op_greaterequal"; tkPrec( tOp_greaterequal ) := 3; tOp_equal := 11; tkName( tOp_equal ) := "Op_equal"; tkPrec( tOp_equal ) := 2; tOp_notequal := 12; tkName( tOp_notequal ) := "Op_notequal"; tkPrec( tOp_notequal ) := 2; tOp_not := 13; tkName( tOp_not ) := "Op_not"; tkPrec( tOp_not ) := -1; tOp_assign := 14; tkName( tOp_assign ) := "Op_assign"; tkPrec( tOp_assign ) := -1; tOp_and := 15; tkName( tOp_and ) := "Op_and"; tkPrec( tOp_and ) := 1; tOp_or := 16; tkName( tOp_or ) := "Op_or"; tkPrec( tOp_or ) := 0; tLeftParen := 17; tkName( tLeftParen ) := "LeftParen"; tkPrec( tLeftParen ) := -1; tRightParen := 18; tkName( tRightParen ) := "RightParen"; tkPrec( tRightParen ) := -1; tLeftBrace := 19; tkName( tLeftBrace ) := "LeftBrace"; tkPrec( tLeftBrace ) := -1; tRightBrace := 20; tkName( tRightBrace ) := "RightBrace"; tkPrec( tRightBrace ) := -1; tSemicolon := 21; tkName( tSemicolon ) := "Semicolon"; tkPrec( tSemicolon ) := -1; tComma := 22; tkName( tComma ) := "Comma"; tkPrec( tComma ) := -1; tKeyword_if := 23; tkName( tKeyword_if ) := "Keyword_if"; tkPrec( tKeyword_if ) := -1; tKeyword_else := 24; tkName( tKeyword_else ) := "Keyword_else"; tkPrec( tKeyword_else ) := -1; tKeyword_while := 25; tkName( tKeyword_while ) := "Keyword_while"; tkPrec( tKeyword_while ) := -1; tKeyword_print := 26; tkName( tKeyword_print ) := "Keyword_print"; tkPrec( tKeyword_print ) := -1; tKeyword_putc := 27; tkName( tKeyword_putc ) := "Keyword_putc"; tkPrec( tKeyword_putc ) := -1; tIdentifier := 28; tkName( tIdentifier ) := "Identifier"; tkPrec( tIdentifier ) := -1; tInteger := 29; tkName( tInteger ) := "Integer"; tkPrec( tInteger ) := -1; tString := 30; tkName( tString ) := "String"; tkPrec( tString ) := -1; tEnd_of_input := 31; tkName( tEnd_of_input ) := "End_of_input"; tkPrec( tEnd_of_input ) := -1; MAX_TOKEN_TYPE := 31; TEXT_MAX := 4095; textNext := 0; PRIMARY_PREC := 6; for tkPos := 1 until MAX_TOKEN_TYPE do tkNode( tkPos ) := - tkPos; tkNode( tOp_multiply ) := nMultiply; tkNode( tOp_divide ) := nDivide; tkNode( tOp_mod ) := nMod; tkNode( tOp_add ) := nAdd; tkNode( tOp_subtract ) := nSubtract; tkNode( tOp_less ) := nLess; tkNode( tOp_lessequal ) := nLessEqual; tkNode( tOp_greater ) := nGreater; tkNode( tOp_greaterequal ) := nGreaterEqual; tkNode( tOp_equal ) := nEqual; tkNode( tOp_notequal ) := nNotEqual; tkNode( tOp_not ) := nNot; tkNode( tOp_and ) := nAnd; tkNode( tOp_or ) := nOr; stList := idList := null; % parse the output from the lexical analyser and output the linearised parse tree % readToken; writeNode( parseStatementList( tEnd_of_input ) ) end.
http://rosettacode.org/wiki/Conway%27s_Game_of_Life	Conway's Game of Life	The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.	#AutoHotkey	AutoHotkey	rows := cols := 10 ; set grid dimensions i = -1,0,1, -1,1, -1,0,1 ; neighbors' x-offsets j = -1,-1,-1, 0,0, 1,1,1 ; neighbors' y-offsets StringSplit i, i, `, ; make arrays StringSplit j, j, `, Loop % rows { ; setup grid of checkboxes r := A_Index, y := r17-8 ; looks good in VISTA Loop % cols { c := A_Index, x := c17-5 Gui Add, CheckBox, x%x% y%y% w17 h17 vv%c%_%r% gCheck } } Gui Add, Button, % "x12 w" x+2, step ; button to step to next generation Gui Show Return Check: GuiControlGet %A_GuiControl% ; manual set of cells Return ButtonStep: ; move to next generation Loop % rows { r := A_Index Loop % cols { c := A_Index, n := 0 Loop 8 ; w[x,y] <- new states x := c+i%A_Index%, y := r+j%A_Index%, n += 1=v%x%_%y% GuiControl,,v%c%_%r%,% w%c%_%r% := v%c%_%r% ? n=2 \|\| n=3 : n=3 } } Loop % rows { ; update v[x,y] = states r := A_Index Loop % cols v%A_Index%_%r% := w%A_Index%_%r% } Return GuiClose: ; exit when GUI is closed ExitApp
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#MATLAB_.2F_Octave	MATLAB / Octave	point.x=3; point.y=4;
http://rosettacode.org/wiki/Compound_data_type	Compound data type	Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack	#Maxima	Maxima	defstruct(point(x, y))$ p: new(point)$ q: point(1, 2)$ p@x: 5$
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Simula	Simula	BEGIN TEXT ORIGINAL, REFERENCE, COPY1; ORIGINAL :- "THIS IS CONSTANT TEXT"; ORIGINAL.SETPOS(1); REFERENCE :- ORIGINAL; ! RUN TIME ERROR: ! ORIGINAL.PUTCHAR('X'); ! "copy-a-string.sim", line 9: ./copy-a-string: Putchar: Constant text object ; OUTTEXT(ORIGINAL); OUTIMAGE; ! CONTENT EQUAL? => T ; OUTTEXT(IF ORIGINAL = REFERENCE THEN "T" ELSE "F"); OUTIMAGE; ! SAME TEXT OBJECT? => T ; OUTTEXT(IF ORIGINAL == REFERENCE THEN "T" ELSE "F"); OUTIMAGE; COPY1 :- COPY(ORIGINAL); COPY1.SETPOS(1); COPY1.PUTCHAR('X'); OUTTEXT(COPY1); OUTIMAGE; END;
http://rosettacode.org/wiki/Copy_a_string	Copy a string	This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet	#Slate	Slate	[ \| :s \| s == s copy] applyTo: {'hello'}. "returns False"
http://rosettacode.org/wiki/Constrained_random_points_on_a_circle	Constrained random points on a circle	Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.	#R	R	RMin <- 10 RMax <- 15 NPts <- 100 # instead of a for loop, we generate what should be enough points # also take care to have enough range to avoid rounding inaccuracies nBlock <- NPts * ((RMax/RMin) ^ 2) nValid <- 0 while (nValid < NPts) { X <- round(runif(nBlock, -RMax - 1, RMax + 1)) Y <- round(runif(nBlock, -RMax - 1, RMax + 1)) R <- sqrt(X^2 + Y^2) Valid <- ( (R >= RMin) & (R <= RMax) ) nValid <- sum(Valid) nBlock <- 2 * nBlock } plot(X[Valid][1:NPts],Y[Valid][1:NPts], pch=19, cex=0.25, col="blue", xlab="x",ylab="y",main="Fuzzy circle", xlim=c(-RMax,RMax), ylim=c(-RMax,RMax) )
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Rust	Rust	extern crate rand; use std::thread; use rand::thread_rng; use rand::distributions::{Range, IndependentSample}; fn main() { let mut rng = thread_rng(); let rng_range = Range::new(0u32, 100); for word in "Enjoy Rosetta Code".split_whitespace() { let snooze_time = rng_range.ind_sample(&mut rng); let local_word = word.to_owned(); std::thread::spawn(move \|\| { thread::sleep_ms(snooze_time); println!("{}", local_word); }); } thread::sleep_ms(1000); }
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Scala	Scala	import scala.actors.Futures List("Enjoy", "Rosetta", "Code").map { x => Futures.future { Thread.sleep((Math.random * 1000).toInt) println(x) } }.foreach(_())
http://rosettacode.org/wiki/Concurrent_computing	Concurrent computing	Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.	#Scheme	Scheme	(parallel-execute (lambda () (print "Enjoy")) (lambda () (print "Rosetta")) (lambda () (print "Code")))
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#XLISP	XLISP	(defmacro f10-at-compile-time () (* 2 3 4 5 6 7 8 9 10))
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#XPL0	XPL0	code IntOut=11; IntOut(0, 1098765432);
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#zkl	zkl	const { [1..10].reduce(').println(" parse time") } #fcn fact(N) { [1..N].reduce(').println(" tokenize time"); ""} // paste output of fact into source #tokenize fact(10) println("compiled program running.");
http://rosettacode.org/wiki/Compile-time_calculation	Compile-time calculation	Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.	#Zig	Zig	const std = @import("std"); fn factorial(n: u64) u64 { var total: u64 = 1; var i: u64 = 1; while (i < n + 1) : (i += 1) { total *= i; } return total; } pub fn main() void { @setEvalBranchQuota(1000); // minimum loop quota for backwards branches const res = comptime factorial(10); // arbitrary Compile Time Function Evaluation std.debug.print("res: {d}", .{res}); // output only at runtime }
http://rosettacode.org/wiki/Conditional_structures	Conditional structures	Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.	#Aime	Aime	if (c1) { // first condition is true... } elif (c2) { // second condition is true... } elif (c3) { // third condition is true... } else { // none was true... }

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#JSON

JSON

{"x":1,"y":2}

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Julia

Julia

struct Point{T<:Real} x::T y::T end

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#RLaB

RLaB

>> s1 = "A string" A string >> s2 = s1 A string

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Robotic

Robotic

set "$string1" to "This is a string" set "$string2" to "$string1" * "&$string2&"

http://rosettacode.org/wiki/Constrained_random_points_on_a_circle

Constrained random points on a circle

Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.

#PicoLisp

PicoLisp

(let Area (make (do 31 (link (need 31 " ")))) (use (X Y) (do 100 (until (>= 15 (sqrt (+ (* (setq X (rand -15 15)) X) (* (setq Y (rand -15 15)) Y) ) ) 10 ) ) (set (nth Area (+ 16 X) (+ 16 Y)) "#") ) ) (mapc prinl Area) )

http://rosettacode.org/wiki/Convex_hull

Convex hull

Find the points which form a convex hull from a set of arbitrary two dimensional points. For example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15). See also Convex Hull (youtube) http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/

#Tcl

Tcl

catch {namespace delete test_convex_hull} ;# Start with a clean namespace namespace eval test_convex_hull { package require Tcl 8.5 ;# maybe earlier? interp alias {} @ {} lindex;# An essential readability helper for list indexing proc cross {o a b} { ### 2D cross product of OA and OB vectors ### return [expr {([@ $a 0] - [@ $o 0]) * ([@ $b 1] - [@ $o 1]) - ([@ $a 1] - [@ $o 1]) * ([@ $b 0] - [@ $o 0]) }] } proc calc_hull_edge {points} { ### Build up hull edge ### set edge [list] foreach p $points { while {[llength $edge ] >= 2 && [cross [@ $edge end-1] [@ $edge end] $p] <= 0} { set edge [lreplace $edge end end] ;# pop } lappend edge $p } return $edge } proc convex_hull {points} { ### Convex hull of a set of 2D points ### # Unique points set points [lsort -unique $points] # Sorted points set points [lsort -real -index 0 [lsort -real -index 1 $points]] # No calculation necessary if {[llength $points] <= 1} { return $points } set lower [calc_hull_edge $points] set upper [calc_hull_edge [lreverse $points]] return [concat [lrange $lower 0 end-1] [lrange $upper 0 end-1]] } # Testing set tpoints {{16 3} {12 17} {0 6} {-4 -6} {16 6} {16 -7} {16 -3} {17 -4} {5 19} {19 -8} {3 16} {12 13} {3 -4} {17 5} {-3 15} {-3 -9} {0 11} {-9 -3} {-4 -2} {12 10}} puts "Test points:" puts [lrange $tpoints 0 end] ;# prettier puts "Convex Hull:" puts [convex_hull $tpoints] }

http://rosettacode.org/wiki/Convert_seconds_to_compound_duration

Convert seconds to compound duration

Task Write a function or program which: takes a positive integer representing a duration in seconds as input (e.g., 100), and returns a string which shows the same duration decomposed into: weeks, days, hours, minutes, and seconds. This is detailed below (e.g., "2 hr, 59 sec"). Demonstrate that it passes the following three test-cases: Test Cases input number output string 7259 2 hr, 59 sec 86400 1 d 6000000 9 wk, 6 d, 10 hr, 40 min Details The following five units should be used: unit suffix used in output conversion week wk 1 week = 7 days day d 1 day = 24 hours hour hr 1 hour = 60 minutes minute min 1 minute = 60 seconds second sec However, only include quantities with non-zero values in the output (e.g., return "1 d" and not "0 wk, 1 d, 0 hr, 0 min, 0 sec"). Give larger units precedence over smaller ones as much as possible (e.g., return 2 min, 10 sec and not 1 min, 70 sec or 130 sec) Mimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).

#XPL0

XPL0

char Str(80); func Duration(Sec); \Convert seconds to compound duration int Sec, Amt, Unit, DoComma, I, Quot; [Amt:= [7*24*60*60, 24*60*60, 60*60, 60, 1]; Unit:= [" wk", " d", " hr", " min", " sec"]; DoComma:= false; for I:= 0 to 4 do [Quot:= Sec/Amt(I); Sec:= rem(0); if Quot # 0 then [if DoComma then Text(8, ", "); DoComma:= true; IntOut(8, Quot); Text(8, Unit(I)); ]; ]; ChOut(8, $0D); ChOut(8, $8A); \terminating CR+LF I:= 0; loop [Str(I):= ChIn(8); if Str(I) >= $80 then return Str; I:= I+1; ]; ]; [Text(0, Duration(7259)); Text(0, Duration(86400)); Text(0, Duration(6_000_000)); ]

http://rosettacode.org/wiki/Convert_seconds_to_compound_duration

Convert seconds to compound duration

Task Write a function or program which: takes a positive integer representing a duration in seconds as input (e.g., 100), and returns a string which shows the same duration decomposed into: weeks, days, hours, minutes, and seconds. This is detailed below (e.g., "2 hr, 59 sec"). Demonstrate that it passes the following three test-cases: Test Cases input number output string 7259 2 hr, 59 sec 86400 1 d 6000000 9 wk, 6 d, 10 hr, 40 min Details The following five units should be used: unit suffix used in output conversion week wk 1 week = 7 days day d 1 day = 24 hours hour hr 1 hour = 60 minutes minute min 1 minute = 60 seconds second sec However, only include quantities with non-zero values in the output (e.g., return "1 d" and not "0 wk, 1 d, 0 hr, 0 min, 0 sec"). Give larger units precedence over smaller ones as much as possible (e.g., return 2 min, 10 sec and not 1 min, 70 sec or 130 sec) Mimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).

#zkl

zkl

fcn toWDHMS(sec){ //-->(wk,d,h,m,s) r,b:=List(),0; foreach u in (T(60,60,24,7)){ sec,b=sec.divr(u); // aka divmod r.append(b); } r.append(sec).reverse() }

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Perl

Perl

use threads; use Time::HiRes qw(sleep); $_->join for map { threads->create(sub { sleep rand; print shift, "\n"; }, $_) } qw(Enjoy Rosetta Code);

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Phix

Phix

without js -- (threads) procedure echo(string s) sleep(rand(100)/100) enter_cs() puts(1,s) puts(1,'\n') leave_cs() end procedure constant threads = {create_thread(routine_id("echo"),{"Enjoy"}), create_thread(routine_id("echo"),{"Rosetta"}), create_thread(routine_id("echo"),{"Code"})} wait_thread(threads) puts(1,"done") {} = wait_key()

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Oz

Oz

functor import System Application prepare fun {Fac N} {FoldL {List.number 1 N 1} Number.'*' 1} end Fac10 = {Fac 10} define {System.showInfo "10! = "#Fac10} {Application.exit 0} end

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Pascal

Pascal

program in out; const X = 10*9*8*7*6*5*4*3*2*1 ; begin writeln(x); end;

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Perl

Perl

my $tenfactorial; print "$tenfactorial\n"; BEGIN {$tenfactorial = 1; $tenfactorial *= $_ foreach 1 .. 10;}

http://rosettacode.org/wiki/Conditional_structures

Conditional structures

Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.

#68000_Assembly

68000 Assembly

MOVE.L #$FFFFFF00,D0 CMP.B #0,D0 ;equals zero, so zero flag is set. CMP.W #0,D0 ;doesn't equals zero, so zero flag is clear.

http://rosettacode.org/wiki/Conway%27s_Game_of_Life

Conway's Game of Life

The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.

#Ada

Ada

WITH Ada.Text_IO; USE Ada.Text_IO; PROCEDURE Life IS SUBTYPE Cell IS Natural RANGE 0 .. 1; TYPE Petri_Dish IS ARRAY (Positive RANGE <>, Positive RANGE <>) OF Cell; PROCEDURE Step (Gen : IN OUT Petri_Dish) IS Above : ARRAY (Gen'Range (2)) OF Cell := (OTHERS => 0); Left, This : Cell; BEGIN FOR I IN Gen'First (1) + 1 .. Gen'Last (1) - 1 LOOP Left := 0; FOR J IN Gen'First (2) + 1 .. Gen'Last (2) - 1 LOOP This := (CASE Above (J - 1) + Above (J) + Above (J + 1) + Left + Gen (I, J + 1) + Gen (I + 1, J - 1) + Gen (I + 1, J) + Gen (I + 1, J + 1) IS WHEN 2 => Gen (I, J), WHEN 3 => 1, WHEN OTHERS => 0); Above (J - 1):= Left; Left := Gen (I, J); Gen (I, J) := This; END LOOP; Above (Above'Last - 1) := Left; END LOOP; END Step; PROCEDURE Put (Gen : Petri_Dish) IS BEGIN FOR I IN Gen'Range (1) LOOP FOR J IN Gen'Range (2) LOOP Put ( if Gen (I, J) = 0 then " " else "#"); END LOOP; New_Line; END LOOP; END Put; Blinker : Petri_Dish := (2 .. 4 => (0, 0, 1, 0, 0), 1 | 5 => (0, 0, 0, 0, 0)); Glider : Petri_Dish (1..6,1..11):= (2 => (3 => 1, others => 0), 3 => (4 => 1, others => 0), 4 => (2|3|4=>1, others => 0), others => (others => 0)); PROCEDURE Put_And_Step_Generation (N : Positive; Name : String; P : IN OUT Petri_Dish) IS BEGIN FOR Generation IN 1 .. N LOOP Put_Line (Name & Generation'Img); Put (P); Step (P); END LOOP; END Put_And_Step_Generation; BEGIN Put_And_Step_Generation (3, "Blinker", Blinker); Put_And_Step_Generation (5, "Glider", Glider); END Life;

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#KonsolScript

KonsolScript

Var:Create( Point, Number x, Number y )

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Kotlin

Kotlin

data class Point(var x: Int, var y: Int) fun main(args: Array<String>) { val p = Point(1, 2) println(p) p.x = 3 p.y = 4 println(p) }

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Ruby

Ruby

original = "hello" reference = original # copies reference copy1 = original.dup # instance of original.class copy2 = String.new(original) # instance of String original << " world!" # append p reference #=> "hello world!" p copy1 #=> "hello" p copy2 #=> "hello"

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Run_BASIC

Run BASIC

origString$ = "Hello!" ' create original string newString$ = origString$ ' make new strig from original

http://rosettacode.org/wiki/Constrained_random_points_on_a_circle

Constrained random points on a circle

Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.

#PL.2FI

PL/I

constrain: procedure options (main); declare 1 point (100), 2 x fixed binary, 2 y fixed binary; declare (i, j, a, b, c) fixed binary; j = 0; do i = 1 to 100; a = 30*random()-15; b = 30*random()-15; c = sqrt(a**2 + b**2); if abs(c) >= 10 & abs(c) <= 15 then do; j = j + 1; x(j) = a; y(j) = b; end; end; /* PLOT */ declare table(-15:15, -15:15) character (1); table = ' '; do i = 1 to j; table(x(i), y(i)) = '*'; end; do i = -15 to 15; put skip; do j = -15 to 15; put edit (table(i,j)) (a); end; end; end constrain;

http://rosettacode.org/wiki/Convex_hull

Convex hull

Find the points which form a convex hull from a set of arbitrary two dimensional points. For example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15). See also Convex Hull (youtube) http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/

#Visual_Basic_.NET

Visual Basic .NET

Imports ConvexHull Module Module1 Class Point : Implements IComparable(Of Point) Public Property X As Integer Public Property Y As Integer Public Sub New(x As Integer, y As Integer) Me.X = x Me.Y = y End Sub Public Function CompareTo(other As Point) As Integer Implements IComparable(Of Point).CompareTo Return X.CompareTo(other.X) End Function Public Overrides Function ToString() As String Return String.Format("({0}, {1})", X, Y) End Function End Class Function ConvexHull(p As List(Of Point)) As List(Of Point) If p.Count = 0 Then Return New List(Of Point) End If p.Sort() Dim h As New List(Of Point) ' Lower hull For Each pt In p While h.Count >= 2 AndAlso Not Ccw(h(h.Count - 2), h(h.Count - 1), pt) h.RemoveAt(h.Count - 1) End While h.Add(pt) Next ' Upper hull Dim t = h.Count + 1 For i = p.Count - 1 To 0 Step -1 Dim pt = p(i) While h.Count >= t AndAlso Not Ccw(h(h.Count - 2), h(h.Count - 1), pt) h.RemoveAt(h.Count - 1) End While h.Add(pt) Next h.RemoveAt(h.Count - 1) Return h End Function Function Ccw(a As Point, b As Point, c As Point) As Boolean Return ((b.X - a.X) * (c.Y - a.Y)) > ((b.Y - a.Y) * (c.X - a.X)) End Function Sub Main() Dim points As New List(Of Point) From { New Point(16, 3), New Point(12, 17), New Point(0, 6), New Point(-4, -6), New Point(16, 6), New Point(16, -7), New Point(16, -3), New Point(17, -4), New Point(5, 19), New Point(19, -8), New Point(3, 16), New Point(12, 13), New Point(3, -4), New Point(17, 5), New Point(-3, 15), New Point(-3, -9), New Point(0, 11), New Point(-9, -3), New Point(-4, -2), New Point(12, 10) } Dim hull = ConvexHull(points) Dim it = hull.GetEnumerator() Console.Write("Convex Hull: [") If it.MoveNext() Then Console.Write(it.Current) End If While it.MoveNext() Console.Write(", {0}", it.Current) End While Console.WriteLine("]") End Sub End Module

http://rosettacode.org/wiki/Convert_seconds_to_compound_duration

Convert seconds to compound duration

Task Write a function or program which: takes a positive integer representing a duration in seconds as input (e.g., 100), and returns a string which shows the same duration decomposed into: weeks, days, hours, minutes, and seconds. This is detailed below (e.g., "2 hr, 59 sec"). Demonstrate that it passes the following three test-cases: Test Cases input number output string 7259 2 hr, 59 sec 86400 1 d 6000000 9 wk, 6 d, 10 hr, 40 min Details The following five units should be used: unit suffix used in output conversion week wk 1 week = 7 days day d 1 day = 24 hours hour hr 1 hour = 60 minutes minute min 1 minute = 60 seconds second sec However, only include quantities with non-zero values in the output (e.g., return "1 d" and not "0 wk, 1 d, 0 hr, 0 min, 0 sec"). Give larger units precedence over smaller ones as much as possible (e.g., return 2 min, 10 sec and not 1 min, 70 sec or 130 sec) Mimic the formatting shown in the test-cases (quantities sorted from largest unit to smallest and separated by comma+space; value and unit of each quantity separated by space).

#ZX_Spectrum_Basic

ZX Spectrum Basic

10 LET m=60: LET h=60*m: LET d=h*24: LET w=d*7 20 DATA 10,7259,86400,6000000,0,1,60,3600,604799,604800,694861 30 READ n 40 FOR i=1 TO n 50 READ s 60 LET nweek=0: LET nday=0: LET nhour=0: LET nmin=0: LET nsec=0: LET s$="" 70 PRINT s;" = "; 80 IF s>=w THEN LET nweek=INT (s/w): LET s=FN m(s,w) 90 IF s>=d THEN LET nday=INT (s/d): LET s=FN m(s,d) 100 IF s>=h THEN LET nhour=INT (s/h): LET s=FN m(s,h) 110 IF s>=m THEN LET nmin=INT (s/m): LET s=FN m(s,m) 120 LET nsec=INT (s) 130 IF nweek>0 THEN LET s$=s$+STR$ nweek+" wk, " 140 IF nday>0 THEN LET s$=s$+STR$ nday+" d, " 150 IF nhour>0 THEN LET s$=s$+STR$ nhour+" hr, " 160 IF nmin>0 THEN LET s$=s$+STR$ nmin+" min, " 170 IF nsec>0 THEN LET s$=s$+STR$ nsec+" sec" 180 IF s$<>"" THEN IF s$(LEN s$-1)="," THEN LET s$=s$( TO LEN s$-2) 190 PRINT s$ 200 NEXT i 210 STOP 220 DEF FN m(a,b)=a-INT (a/b)*b

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#PicoLisp

PicoLisp

(for (N . Str) '("Enjoy" "Rosetta" "Code") (task (- N) (rand 1000 4000) # Random start time 1 .. 4 sec Str Str # Closure with string value (println Str) # Task body: Print the string (task @) ) ) # and stop the task

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Pike

Pike

int main() { // Start threads and wait for them to finish ({ Thread.Thread(write, "Enjoy\n"), Thread.Thread(write, "Rosetta\n"), Thread.Thread(write, "Code\n") })->wait(); // Exit program exit(0); }

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Phix

Phix

integer a,b a = 10*9*8*7*6*5*4*3*2*1 b = factorial(10) ?{a,b}

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#PicoLisp

PicoLisp

(de fact (N) (apply * (range 1 N)) ) (de foo () (prinl "The value of fact(10) is " `(fact 10)) )

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#PL.2FI

PL/I

/* Factorials using the pre-processor. */ test: procedure options (main); %factorial: procedure (N) returns (fixed); declare N fixed; declare (i, k) fixed; k = 1; do i = 2 to N; k = k*i; end; return (k); %end factorial; %activate factorial; declare (x, y) fixed decimal; x = factorial (4); put ('factorial 4 is ', x); y = factorial (6); put skip list ('factorial 6 is ', y); end test;

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#PowerShell

PowerShell

function fact([BigInt]$n){ if($n -ge ([BigInt]::Zero)) { $fact = [BigInt]::One ([BigInt]::One)..$n | foreach{ $fact = [BigInt]::Multiply($fact, $_) } $fact } else { Write-Error "$n is lower than 0" } } "$((Measure-Command {$fact = fact 10}).TotalSeconds) Seconds" $fact

http://rosettacode.org/wiki/Conditional_structures

Conditional structures

Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.

#AArch64_Assembly

AArch64 Assembly

/* ARM assembly AARCH64 Raspberry PI 3B */ /* program condstr64.s */ /*******************************************/ /* Constantes file */ /*******************************************/ /* for this file see task include a file in language AArch64 assembly*/ .include "../includeConstantesARM64.inc" /*******************************************/ /* Initialized data */ /*******************************************/ .data szMessTest1: .asciz "The test 1 is equal.\n" szMessTest1N: .asciz "The test 1 is not equal.\n" szMessTest1A: .asciz "The test 1A is equal.\n" szMessTest1AN: .asciz "The test 1A is not equal.\n" szMessTest2: .asciz "The test 2 is equal.\n" szMessTest2N: .asciz "The test 2 is not equal.\n" szMessTest3: .asciz "The test 3 is <.\n" szMessTest3N: .asciz "The test 3 is >.\n" szMessTest4: .asciz "The test 4 is <=.\n" szMessTest4N: .asciz "The test 4 is >.\n" szMessTest5: .asciz "The test 5 is negative.\n" szMessTest5N: .asciz "The test 5 is positive ou equal 0.\n" szMessTest6: .asciz "Test 6 : carry is off.\n" szMessTest6N: .asciz "Test 6 : carry is set.\n" szMessTest7: .asciz "Test 7 : no overflow.\n" szMessTest7N: .asciz "Test 7 : overflow.\n" szMessTest8: .asciz "Test 8 : then.\n" szMessTest8N: .asciz "Test 8 : else.\n" szMessResult: .asciz "Test result = @ \n" /*******************************************/ /* UnInitialized data */ /*******************************************/ .bss sZoneConv: .skip 30 /*******************************************/ /* code section */ /*******************************************/ .text .global main main: // entry of program // classic test equal zero, not equal zero //mov x1,0 // comments mov x1,1 // or uncomments cmp x1,0 // structure if else bne 1f ldr x0,qAdrszMessTest1 // if equal b 2f 1: ldr x0,qAdrszMessTest1N // else 2: bl affichageMess mov x1,0 // comments //mov x1,1 // or uncomments cbnz x1,3f // other test and branch if not zero ldr x0,qAdrszMessTest1A b 4f 3: ldr x0,qAdrszMessTest1AN 4: bl affichageMess // test equal 5, not equal 5 //mov x1,#5 mov x1,10 cmp x1,5 bne 5f ldr x0,qAdrszMessTest2 b 6f 5: ldr x0,qAdrszMessTest2N 6: bl affichageMess // test < 5, > 5 SIGNED mov x1,#-10 //mov x1,#10 cmp x1,#5 bgt 7f ldr x0,qAdrszMessTest3 b 8f 7: ldr x0,qAdrszMessTest3N 8: bl affichageMess // test < 5, > 5 UNSIGNED //mov x1,#-10 mov x1,#2 cmp x1,#5 bhi 9f ldr x0,qAdrszMessTest4 b 10f 9: ldr x0,qAdrszMessTest4N 10: bl affichageMess // test < 0, > 0 mov x1,2 subs x1,x1,5 // s --> flags bpl 11f ldr x0,qAdrszMessTest5 b 12f 11: ldr x0,qAdrszMessTest5N 12: bl affichageMess // carry off carry on //mov x1,#-10 // for carry set //mov x1,#10 // for carry off mov x1,(2<<62) - 1 // for carry off adds x1,x1,20 // s --> flags bcs 13f ldr x0,qAdrszMessTest6 // carry clear b 14f 13: ldr x0,qAdrszMessTest6N // carry set 14: bl affichageMess // overflow off overflow on //mov x1,#-10 // for not overflow //mov x1,#10 // for not overflow mov x1,(2<<62) - 1 // for overflow adds x1,x1,20 // s --> flags bvs 15f ldr x0,qAdrszMessTest7 // overflow off b 16f 15: ldr x0,qAdrszMessTest7N // overflow on 16: bl affichageMess // other conditionnel test csel mov x2,-20 mov x3,25 mov x1,10 // for equal //mov x1,#20 // for else cmp x1,10 csel x0,x2,x3,eq // if x1=10 x0 = x2 else x0 = x3 ldr x1,qAdrsZoneConv bl conversion10S ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv bl strInsertAtCharInc // insert result at @ character bl affichageMess // other conditionnel test cset //mov x1,10 // for equal mov x1,20 // for else cmp x1,10 cset x0,eq // if x1=10 x0 = 1 else x0 = 0 ldr x1,qAdrsZoneConv bl conversion10S ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv bl strInsertAtCharInc // insert result at @ character bl affichageMess // other conditionnel test cinc mov x0,3 mov x1,10 // for equal //mov x1,20 // for else cmp x1,10 cinc x0,x0,eq // if x1=10 x0 = x0+1 else x0 = x0 ldr x1,qAdrsZoneConv bl conversion10S ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv bl strInsertAtCharInc // insert result at @ character bl affichageMess // other conditionnel test csinc mov x0,3 mov x2,6 mov x3,11 mov x1,10 // for equal //mov x1,20 // for else cmp x1,10 csinc x0,x2,x3,ne // if x1<>10 x0 = x2 else x0 = x3 + 1 ldr x1,qAdrsZoneConv bl conversion10S ldr x0,qAdrszMessResult ldr x1,qAdrsZoneConv bl strInsertAtCharInc // insert result at @ character bl affichageMess 100: // standard end of the program mov x0,0 // return code mov x8,EXIT // request to exit program svc 0 // perform the system call qAdrszMessTest1: .quad szMessTest1 qAdrszMessTest1N: .quad szMessTest1N qAdrszMessTest1A: .quad szMessTest1A qAdrszMessTest1AN: .quad szMessTest1AN qAdrszMessTest2: .quad szMessTest2 qAdrszMessTest2N: .quad szMessTest2N qAdrszMessTest3: .quad szMessTest3 qAdrszMessTest3N: .quad szMessTest3N qAdrszMessTest4: .quad szMessTest4 qAdrszMessTest4N: .quad szMessTest4N qAdrszMessTest5: .quad szMessTest5 qAdrszMessTest5N: .quad szMessTest5N qAdrszMessTest6: .quad szMessTest6 qAdrszMessTest6N: .quad szMessTest6N qAdrszMessTest7: .quad szMessTest7 qAdrszMessTest7N: .quad szMessTest7N qAdrszMessTest8: .quad szMessTest8 qAdrszMessTest8N: .quad szMessTest8N qAdrszMessResult: .quad szMessResult qAdrsZoneConv: .quad sZoneConv /********************************************************/ /* File Include fonctions */ /********************************************************/ /* for this file see task include a file in language AArch64 assembly */ .include "../includeARM64.inc"

http://rosettacode.org/wiki/Conway%27s_Game_of_Life

Conway's Game of Life

The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.

#ALGOL_68

ALGOL 68

∇LIFE[⎕]∇ [0] NG←LIFE CG;W [1] W←CG+(¯1⊖CG)+(1⊖CG)+(¯1⌽CG)+(1⌽CG) [2] W←W+(1⊖1⌽CG)+(¯1⊖1⌽CG)+(1⊖¯1⌽CG)+(¯1⊖¯1⌽CG) [3] NG←(3=W)+(CG∧4=W) ∇ RP←5 5⍴0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 RP 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 LIFE RP 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 LIFE LIFE RP 0 0 1 0 0 0 1 1 0 0 1 0 0 1 0 0 1 1 0 0 0 0 0 0 0

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Lambdatalk

Lambdatalk

1) a pair {def P {P.new 1 2}} -> P {P.left {P}} -> 1 {P.right {P}} -> 2 2) its Lispsish variant {def Q {cons 1 2}} -> Q {car {Q}} -> 1 {cdr {Q}} -> 2 3) as an array {def R {A.new 1 2}} -> R {A.first {R}} -> 1 {A.last {R}} -> 2

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Lasso

Lasso

define Point => type { parent pair public onCreate(x,y) => { ..onCreate(#x=#y) } public x => .first public y => .second } local(point) = Point(33, 42) #point->x #point->y

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Rust

Rust

fn main() { let s1 = "A String"; let mut s2 = s1; s2 = "Another String"; println!("s1 = {}, s2 = {}", s1, s2); }

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Sather

Sather

class MAIN is main is s ::= "a string"; s1 ::= s; -- s1 is a copy end; end;

http://rosettacode.org/wiki/Constrained_random_points_on_a_circle

Constrained random points on a circle

Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.

#PowerShell

PowerShell

$MinR2 = 10 * 10 $MaxR2 = 15 * 15 $Points = @{} While ( $Points.Count -lt 100 ) { $X = Get-Random -Minimum -16 -Maximum 17 $Y = Get-Random -Minimum -16 -Maximum 17 $R2 = $X * $X + $Y * $Y If ( $R2 -ge $MinR2 -and $R2 -le $MaxR2 -and "$X,$Y" -notin $Points.Keys ) { $Points += @{ "$X,$Y" = 1 } } } ForEach ( $Y in -16..16 ) { ( -16..16 | ForEach { ( " ", "*" )[[int]$Points["$_,$Y"]] } ) -join '' }

http://rosettacode.org/wiki/Convex_hull

Convex hull

Find the points which form a convex hull from a set of arbitrary two dimensional points. For example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15). See also Convex Hull (youtube) http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/

#Wren

Wren

import "/sort" for Sort import "/trait" for Comparable, Stepped class Point is Comparable { construct new(x, y) { _x = x _y = y } x { _x } y { _y } compare(other) { (_x != other.x) ? (_x - other.x).sign : (_y - other.y).sign } toString { "(%(_x), %(_y))" } } /* ccw returns true if the three points make a counter-clockwise turn */ var ccw = Fn.new { |a, b, c| ((b.x - a.x) * (c.y - a.y)) > ((b.y - a.y) * (c.x - a.x)) } var convexHull = Fn.new { |pts| if (pts.isEmpty) return [] Sort.quick(pts) var h = [] // lower hull for (pt in pts) { while (h.count >= 2 && !ccw.call(h[-2], h[-1], pt)) h.removeAt(-1) h.add(pt) } // upper hull var t = h.count + 1 for (i in Stepped.descend(pts.count-2..0, 1)) { var pt = pts[i] while (h.count >= t && !ccw.call(h[-2], h[-1], pt)) h.removeAt(-1) h.add(pt) } h.removeAt(-1) return h } var pts = [ Point.new(16, 3), Point.new(12, 17), Point.new( 0, 6), Point.new(-4, -6), Point.new(16, 6), Point.new(16, -7), Point.new(16, -3), Point.new(17, -4), Point.new( 5, 19), Point.new(19, -8), Point.new( 3, 16), Point.new(12, 13), Point.new( 3, -4), Point.new(17, 5), Point.new(-3, 15), Point.new(-3, -9), Point.new( 0, 11), Point.new(-9, -3), Point.new(-4, -2), Point.new(12, 10) ] System.print("Convex Hull: %(convexHull.call(pts))")

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#PowerShell

PowerShell

$Strings = "Enjoy","Rosetta","Code" $SB = {param($String)Write-Output $String} foreach($String in $Strings) { Start-Job -ScriptBlock $SB -ArgumentList $String | Out-Null } Get-Job | Wait-Job | Receive-Job Get-Job | Remove-Job

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Prolog

Prolog

main :- thread_create(say("Enjoy"),A,[]), thread_create(say("Rosetta"),B,[]), thread_create(say("Code"),C,[]), thread_join(A,_), thread_join(B,_), thread_join(C,_). say(Message) :- Delay is random_float, sleep(Delay), writeln(Message).

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Prolog

Prolog

% Taken from RosettaCode Factorial page for Prolog fact(X, 1) :- X<2. fact(X, F) :- Y is X-1, fact(Y,Z), F is Z*X. goal_expansion((X = factorial_of(N)), (X = F)) :- fact(N,F). test :- F = factorial_of(10), format('!10 = ~p~n', F).

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#PureBasic

PureBasic

a=1*2*3*4*5*6*7*8*9*10

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Quackery

Quackery

[ 1 10 times [ i 1+ * ] echo ] now!

http://rosettacode.org/wiki/Conditional_structures

Conditional structures

Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.

#Action.21

Action!

PROC Main() INT i FOR i=-1 TO 1 DO IF i<0 THEN PrintF("%I is less than zero%E",i) ELSEIF i>0 THEN PrintF("%I is greater than zero%E",i) ELSE PrintF("%I is zero%E",i) FI OD RETURN

http://rosettacode.org/wiki/Conway%27s_Game_of_Life

Conway's Game of Life

The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.

#APL

APL

∇LIFE[⎕]∇ [0] NG←LIFE CG;W [1] W←CG+(¯1⊖CG)+(1⊖CG)+(¯1⌽CG)+(1⌽CG) [2] W←W+(1⊖1⌽CG)+(¯1⊖1⌽CG)+(1⊖¯1⌽CG)+(¯1⊖¯1⌽CG) [3] NG←(3=W)+(CG∧4=W) ∇ RP←5 5⍴0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 RP 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 LIFE RP 0 0 0 0 0 0 1 1 1 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 LIFE LIFE RP 0 0 1 0 0 0 1 1 0 0 1 0 0 1 0 0 1 1 0 0 0 0 0 0 0

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#LFE

LFE

(defrecord point x y)

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Lingo

Lingo

-- parent script "MyPoint" property x property y on new (me, px, py) me.x = px me.y = py return me end

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Scala

Scala

val src = "Hello" // Its actually not a copy but a reference // That is not a problem because String is immutable // In fact its a feature val des = src assert(src eq des) // Proves the same reference is used. // To make a real copy makes no sense. // Actually its hard to make a copy, the compiler is too smart. // mkString, toString makes also not a real copy val cop = src.mkString.toString assert((src eq cop)) // Still no copyed image val copy = src.reverse.reverse // Finally double reverse makes a copy assert(src == copy && !(src eq copy))// Prove, but it really makes no sense.

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Scheme

Scheme

(define dst (string-copy src))

http://rosettacode.org/wiki/Constrained_random_points_on_a_circle

Constrained random points on a circle

Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.

#Prolog

Prolog

:- use_module(library(clpfd)). circle :- bagof([X,Y], init(X,Y), BL), length(BL, N), length(L, 100), maplist(choose(BL, N), L), draw_circle(L). % point selection choose(BL, N, V) :- I is random(N), nth0(I, BL, V). % to find all couples of numbers verifying % 100 <= x^2 + y^2 <= 225 init(X1, Y1) :- X in -15..15, Y in -15..15, X*X + Y*Y #>= 100, X*X + Y*Y #=< 225, label([X,Y]), X1 is 10 * X + 200, Y1 is 10 * Y + 200. draw_circle(L) :- new(D, window('Circle')), send(D, size,size(400,400)), forall(member([X,Y], L), ( new(C, circle(4)), send(C, fill_pattern, colour(@default, 0, 0, 0)), send(C, center(point(X,Y))), send(D, display, C))), send(D, open).

http://rosettacode.org/wiki/Convex_hull

Convex hull

Find the points which form a convex hull from a set of arbitrary two dimensional points. For example, given the points (16,3), (12,17), (0,6), (-4,-6), (16,6), (16,-7), (16,-3), (17,-4), (5,19), (19,-8), (3,16), (12,13), (3,-4), (17,5), (-3,15), (-3,-9), (0,11), (-9,-3), (-4,-2) and (12,10) the convex hull would be (-9,-3), (-3,-9), (19,-8), (17,5), (12,17), (5,19) and (-3,15). See also Convex Hull (youtube) http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/

#zkl

zkl

// Use Graham Scan to sort points into a convex hull // https://en.wikipedia.org/wiki/Graham_scan, O(n log n) // http://www.geeksforgeeks.org/convex-hull-set-2-graham-scan/ // http://geomalgorithms.com/a10-_hull-1.html fcn grahamScan(points){ N:=points.len(); # find the point with the lowest y-coordinate, x is tie breaker p0:=points.reduce(fcn([(a,b)]ab,[(x,y)]xy){ if(b<y)ab else if(b==y and a<x)ab else xy }); #sort points by polar angle with p0, ie ccw from p0 points.sort('wrap(p1,p2){ ccw(p0,p1,p2)>0 }); # We want points[0] to be a sentinel point that will stop the loop. points.insert(0,points[-1]); M:=1; # M will denote the number of points on the convex hull. foreach i in ([2..N]){ # Find next valid point on convex hull. while(ccw(points[M-1], points[M], points[i])<=0){ if(M>1) M-=1; else if(i==N) break; # All points are collinear else i+=1; } points.swap(M+=1,i); # Update M and swap points[i] to the correct place. } points[0,M] } # Three points are a counter-clockwise turn if ccw > 0, clockwise if # ccw < 0, and collinear if ccw = 0 because ccw is a determinant that # gives twice the signed area of the triangle formed by p1, p2 and p3. fcn ccw(a,b,c){ // a,b,c are points: (x,y) ((b[0] - a[0])*(c[1] - a[1])) - ((b[1] - a[1])*(c[0] - a[0])) }

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#PureBasic

PureBasic

Global mutex = CreateMutex() Procedure Printer(*str) LockMutex(mutex) PrintN( PeekS(*str) ) UnlockMutex(mutex) EndProcedure If OpenConsole() LockMutex(mutex) thread1 = CreateThread(@Printer(), @"Enjoy") thread2 = CreateThread(@Printer(), @"Rosetta") thread3 = CreateThread(@Printer(), @"Code") UnlockMutex(mutex) WaitThread(thread1) WaitThread(thread2) WaitThread(thread3) Print(#CRLF$ + #CRLF$ + "Press ENTER to exit") Input() CloseConsole() EndIf FreeMutex(mutex)

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Python

Python

import asyncio async def print_(string: str) -> None: print(string) async def main(): strings = ['Enjoy', 'Rosetta', 'Code'] coroutines = map(print_, strings) await asyncio.gather(*coroutines) if __name__ == '__main__': asyncio.run(main())

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Racket

Racket

#lang racket ;; Import the math library for compile-time ;; Note: included in Racket v5.3.2 (require (for-syntax math)) ;; In versions older than v5.3.2, just define the function ;; for compile-time ;; ;; (begin-for-syntax ;; (define (factorial n) ;; (if (zero? n) ;; 1 ;; (factorial (- n 1))))) ;; define a macro that calls factorial at compile-time (define-syntax (fact10 stx) #`#,(factorial 10)) ;; use the macro defined above (fact10)

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Raku

Raku

constant $tenfact = [*] 2..10; say $tenfact;

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#REXX

REXX

/*REXX program computes 10! (ten factorial) during REXX's equivalent of "compile─time". */ say '10! =' !(10) exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ !: procedure; !=1; do j=2 to arg(1); !=!*j; end /*j*/; return !

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Ring

Ring

a = 10*9*8*7*6*5*4*3*2*1 b = factorial(10) see a + nl see b + nl func factorial nr if nr = 1 return 1 else return nr * factorial(nr-1) ok

http://rosettacode.org/wiki/Conditional_structures

Conditional structures

Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.

#ActionScript

ActionScript

type Restricted is range 1..10; My_Var : Restricted; if My_Var = 5 then -- do something elsif My_Var > 5 then -- do something else -- do something end if;

http://rosettacode.org/wiki/Conway%27s_Game_of_Life

Conway's Game of Life

The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.

#AppleScript

AppleScript

use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later use framework "Foundation" -- For the regex at the top of newUniverse() use scripting additions -- The characters to represent the live and dead cells. property live : "■" -- character id 9632 (U+25A0). property dead : space -- Infinite universes are expensive to maintain, so only a local region of universe is represented here. -- Its invisible border is a wall of "dead" cells one cell deep, lined with a two-cell buffer layer into which -- objects nominally leaving the region can disappear without being seen to hit the wall or bouncing back. property borderThickness : 3 on newUniverse(seed, {w, h}) -- Replace every visible character in the seed text with "■" and every horizontal space with a space. set seed to current application's class "NSMutableString"'s stringWithString:(seed) set regex to current application's NSRegularExpressionSearch tell seed to replaceOccurrencesOfString:("\\S") withString:(live) options:(regex) range:({0, its |length|()}) tell seed to replaceOccurrencesOfString:("\\h") withString:(dead) options:(regex) range:({0, its |length|()}) -- Ensure the universe dimensions are at least equal to the number of lines and the length of the longest. set seedLines to paragraphs of (seed as text) set lineCount to (count seedLines) if (lineCount > h) then set h to lineCount set seedWidth to 0 repeat with thisLine in seedLines set lineLength to (count thisLine) if (lineLength > seedWidth) then set seedWidth to lineLength end repeat if (seedWidth > w) then set w to seedWidth -- Get a new universe. script universe -- State lists. These will contain or be lists of 0s and 1s and will include the border cells. property newState : {} property previousState : {} property currentRow : {} property rowAbove : {} property rowBelow : {} property replacementRow : {} -- Equivalent text lists. These will only cover what's in the bounded region. property lineList : {} property characterGrid : {} property currentLineCharacters : {} -- Precalculated border cell indices. property rightInnerBuffer : borderThickness + w + 1 property rightOuterBuffer : rightInnerBuffer + borderThickness - 2 property bottomInnerBuffer : borderThickness + h + 1 property bottomOuterBuffer : bottomInnerBuffer + borderThickness - 2 -- Generation counter. property counter : 0 -- Temporary lists used in the set-up. property rowTemplate : {} property lineCharacterTemplate : {} -- Built-in handlers. Both return text representing a universe state and -- a boolean indicating whether or not the state's the same as the previous one. on nextState() set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to "" copy newState to previousState set currentRow to beginning of my previousState set rowBelow to item 2 of my previousState -- Check each occupiable cell in each occupiable row of the 'previousState' grid, including the buffer cells. -- If warranted by the number of live neighbours, edit the equivalent cell in 'newState' and, -- if within the region's bounds, change the corresponding text character too. repeat with r from 2 to bottomOuterBuffer set rowAbove to currentRow set currentRow to rowBelow set rowBelow to item (r + 1) of my previousState set replacementRow to item r of my newState set rowCrossesRegion to ((r comes after borderThickness) and (r comes before bottomInnerBuffer)) if (rowCrossesRegion) then set currentLineCharacters to item (r - borderThickness) of my characterGrid set lineChanged to false repeat with c from 2 to rightOuterBuffer set liveNeighbours to ¬ (item (c - 1) of my rowAbove) + (item c of my rowAbove) + (item (c + 1) of my rowAbove) + ¬ (item (c - 1) of my currentRow) + (item (c + 1) of my currentRow) + ¬ (item (c - 1) of my rowBelow) + (item c of my rowBelow) + (item (c + 1) of my rowBelow) if (item c of my currentRow is 1) then if ((liveNeighbours < 2) or (liveNeighbours > 3)) then set item c of my replacementRow to 0 if ((c comes after borderThickness) and (c comes before rightInnerBuffer) and (rowCrossesRegion)) then set item (c - borderThickness) of my currentLineCharacters to dead set lineChanged to true else if ((c is 3) or (c is rightOuterBuffer) or (r is 3) or (r is bottomOuterBuffer)) then -- This is a fudge to dissolve "bombers" entering the buffer zone. set item (c - 1) of my replacementRow to -1 set item c of item (r - 1) of my newState to -1 end if end if else if (liveNeighbours is 3) then set item c of my replacementRow to 1 if ((c comes after borderThickness) and (c comes before rightInnerBuffer) and (rowCrossesRegion)) then set item (c - borderThickness) of my currentLineCharacters to live set lineChanged to true end if end if end repeat if (lineChanged) then set item (r - borderThickness) of my lineList to currentLineCharacters as text end repeat set AppleScript's text item delimiters to astid set counter to counter + 1 set last item of my lineList to "Generation " & counter return currentState() end nextState on currentState() set noChanges to (newState = previousState) if (noChanges) then ¬ set last item of my lineList to (last item of my lineList) & " (all dead, still lifes, or left the universe)" set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to return set stateText to lineList as text set AppleScript's text item delimiters to astid return {stateText, noChanges} end currentState end script -- Set the universe's start conditions. -- Build a row template list containing w + 2 * borderThickness zeros -- and a line character template list containing w 'dead' characters. repeat (borderThickness * 2) times set end of universe's rowTemplate to 0 end repeat repeat w times set end of universe's rowTemplate to 0 set end of universe's lineCharacterTemplate to dead end repeat set astid to AppleScript's text item delimiters set AppleScript's text item delimiters to "" set blankLine to universe's lineCharacterTemplate as text -- Use the templates to populate lists representing the universe's conditions. -- Firstly the top border rows ('newState' list only). repeat borderThickness times copy universe's rowTemplate to end of universe's newState end repeat -- Then enough rows and text lines to centre the input roughly halfway down the grid. set headroom to (h - lineCount) div 2 repeat headroom times copy universe's rowTemplate to end of universe's newState copy universe's lineCharacterTemplate to end of universe's characterGrid set end of universe's lineList to blankLine end repeat -- Then the rows and lines representing the input itself, centring it roughly halfway across the grid. set textInset to (w - seedWidth) div 2 set stateInset to textInset + borderThickness repeat with thisLine in seedLines copy universe's rowTemplate to universe's currentRow copy universe's lineCharacterTemplate to universe's currentLineCharacters repeat with c from 1 to (count thisLine) set thisCharacter to character c of thisLine set item (textInset + c) of universe's currentLineCharacters to thisCharacter set item (stateInset + c) of universe's currentRow to (thisCharacter is live) as integer end repeat set end of universe's newState to universe's currentRow set end of universe's characterGrid to universe's currentLineCharacters set end of universe's lineList to universe's currentLineCharacters as text end repeat set AppleScript's text item delimiters to astid -- Then the rows and lines beneath and the bottom border. repeat (h - (headroom + lineCount)) times copy universe's rowTemplate to end of universe's newState copy universe's lineCharacterTemplate to end of universe's characterGrid set end of universe's lineList to blankLine end repeat repeat borderThickness times copy universe's rowTemplate to end of universe's newState end repeat -- Add a generation counter display line to the end of the line list. set end of universe's lineList to "Generation 0" -- Lose the no-longer-needed template lists. set universe's rowTemplate to missing value set universe's lineCharacterTemplate to universe's rowTemplate return universe end newUniverse

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Logo

Logo

setpos [100 100] setpos [100 0] setpos [0 0] show pos ; [0 0]

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Lua

Lua

a = {x = 1; y = 2} b = {x = 3; y = 4} c = { x = a.x + b.x; y = a.y + b.y } print(a.x, a.y) --> 1 2 print(c.x, c.y) --> 4 6

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Seed7

Seed7

var string: dest is ""; dest := "Hello";

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#SenseTalk

SenseTalk

(* In SenseTalk, assignments normally always make copies of values. *) put "glorious" into myWord put myWord into yourWord (* Assignments can also be made by reference if desired. *) put a reference to myWord into myRef set another to refer to myRef put "ly" after myWord put "in" before another put "myWord: " & myWord put "yourWord: " & yourWord put "myRef: " & myRef put "another: " & another

http://rosettacode.org/wiki/Constrained_random_points_on_a_circle

Constrained random points on a circle

Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.

#PureBasic

PureBasic

CreateImage(0,31,31) StartDrawing(ImageOutput(0)) For i=1 To 100 Repeat x=Random(30)-15 y=Random(30)-15 R.f=Sqr(x*x+y*y) Until 10<=R And R<=15 Plot(x+15,y+15,#Red) Next StopDrawing() Title$="PureBasic Plot" Flags=#PB_Window_SystemMenu OpenWindow(0,#PB_Ignore,#PB_Ignore,ImageWidth(0),ImageHeight(0),Title$,Flags) ImageGadget(0,0,0,ImageWidth(0),ImageHeight(0),ImageID(0)) Repeat: Until WaitWindowEvent()=#PB_Event_CloseWindow

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Racket

Racket

#lang racket (for ([str '("Enjoy" "Rosetta" "Code")]) (thread (λ () (displayln str))))

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Raku

Raku

my @words = <Enjoy Rosetta Code>; @words.race(:batch(1)).map: { sleep rand; say $_ };

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Rust

Rust

fn factorial(n: i64) -> i64 { let mut total = 1; for i in 1..n+1 { total *= i; } return total; } fn main() { println!("Factorial of 10 is {}.", factorial(10)); }

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Scala

Scala

object Main extends { val tenFactorial = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 def tenFac = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 println(s"10! = $tenFactorial", tenFac) }

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Seed7

Seed7

$ include "seed7_05.s7i"; const proc: main is func local const integer: factorial is !10; begin writeln(factorial); end func;

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Sidef

Sidef

define n = (10!); say n;

http://rosettacode.org/wiki/Conditional_structures

Conditional structures

Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.

#Ada

Ada

type Restricted is range 1..10; My_Var : Restricted; if My_Var = 5 then -- do something elsif My_Var > 5 then -- do something else -- do something end if;

http://rosettacode.org/wiki/Compiler/AST_interpreter

Compiler/AST interpreter

An AST interpreter interprets an Abstract Syntax Tree (AST) produced by a Syntax Analyzer. Task[edit] Take the AST output from the Syntax analyzer task, and interpret it as appropriate. Refer to the Syntax analyzer task for details of the AST. Loading the AST from the syntax analyzer is as simple as (pseudo code) def load_ast() line = readline() # Each line has at least one token line_list = tokenize the line, respecting double quotes text = line_list[0] # first token is always the node type if text == ";" # a terminal node return NULL node_type = text # could convert to internal form if desired # A line with two tokens is a leaf node # Leaf nodes are: Identifier, Integer, String # The 2nd token is the value if len(line_list) > 1 return make_leaf(node_type, line_list[1]) left = load_ast() right = load_ast() return make_node(node_type, left, right) The interpreter algorithm is relatively simple interp(x) if x == NULL return NULL elif x.node_type == Integer return x.value converted to an integer elif x.node_type == Ident return the current value of variable x.value elif x.node_type == String return x.value elif x.node_type == Assign globals[x.left.value] = interp(x.right) return NULL elif x.node_type is a binary operator return interp(x.left) operator interp(x.right) elif x.node_type is a unary operator, return return operator interp(x.left) elif x.node_type == If if (interp(x.left)) then interp(x.right.left) else interp(x.right.right) return NULL elif x.node_type == While while (interp(x.left)) do interp(x.right) return NULL elif x.node_type == Prtc print interp(x.left) as a character, no newline return NULL elif x.node_type == Prti print interp(x.left) as an integer, no newline return NULL elif x.node_type == Prts print interp(x.left) as a string, respecting newlines ("\n") return NULL elif x.node_type == Sequence interp(x.left) interp(x.right) return NULL else error("unknown node type") Notes: Because of the simple nature of our tiny language, Semantic analysis is not needed. Your interpreter should use C like division semantics, for both division and modulus. For division of positive operands, only the non-fractional portion of the result should be returned. In other words, the result should be truncated towards 0. This means, for instance, that 3 / 2 should result in 1. For division when one of the operands is negative, the result should be truncated towards 0. This means, for instance, that 3 / -2 should result in -1. Test program prime.t lex <prime.t | parse | interp /* Simple prime number generator */ count = 1; n = 1; limit = 100; while (n < limit) { k=3; p=1; n=n+2; while ((k*k<=n) && (p)) { p=n/k*k!=n; k=k+2; } if (p) { print(n, " is prime\n"); count = count + 1; } } print("Total primes found: ", count, "\n"); 3 is prime 5 is prime 7 is prime 11 is prime 13 is prime 17 is prime 19 is prime 23 is prime 29 is prime 31 is prime 37 is prime 41 is prime 43 is prime 47 is prime 53 is prime 59 is prime 61 is prime 67 is prime 71 is prime 73 is prime 79 is prime 83 is prime 89 is prime 97 is prime 101 is prime Total primes found: 26 Additional examples Your solution should pass all the test cases above and the additional tests found Here. Reference The C and Python versions can be considered reference implementations. Related Tasks Lexical Analyzer task Syntax Analyzer task Code Generator task Virtual Machine Interpreter task

#ALGOL_W

ALGOL W

begin % AST interpreter % % parse tree nodes % record node( integer type ; reference(node) left, right ; integer iValue % nString/nIndentifier number or nInteger value % ); integer nIdentifier, nString, nInteger, nSequence, nIf, nPrtc, nPrts , nPrti, nWhile, nAssign, nNegate, nNot, nMultiply , nDivide, nMod, nAdd, nSubtract, nLess, nLessEqual , nGreater, nGreaterEqual, nEqual, nNotEqual, nAnd, nOr ; string(14) array ndName ( 1 :: 25 ); integer MAX_NODE_TYPE; % string literals and identifiers - uses a linked list - a hash table might be better... % string(1) array text ( 0 :: 4095 ); integer textNext, TEXT_MAX; record textElement ( integer start, length; reference(textElement) next ); reference(textElement) idList, stList; % memory - identifiers hold indexes to locations here % integer array data ( 1 :: 4096 ); % returns a new node with left and right branches % reference(node) procedure opNode ( integer value opType; reference(node) value opLeft, opRight ) ; begin node( opType, opLeft, opRight, 0 ) end opNode ; % returns a new operand node % reference(node) procedure operandNode ( integer value opType, opValue ) ; begin node( opType, null, null, opValue ) end operandNode ; % reports an error and stops % procedure rtError( string(80) value message ); begin integer errorPos; write( s_w := 0, "**** Runtime error " ); errorPos := 0; while errorPos < 80 and message( errorPos // 1 ) not = "." do begin writeon( s_w := 0, message( errorPos // 1 ) ); errorPos := errorPos + 1 end while_not_at_end_of_message ; writeon( s_w := 0, "." ); assert( false ) end rtError ; % reads a node from standard input % reference(node) procedure readNode ; begin reference(node) resultNode; % parses a string from line and stores it in a string in the text array % % - if it is not already present in the specified textElement list. % % returns the position of the string in the text array % integer procedure readString ( reference(textElement) value result txList; string(1) value terminator ) ; begin string(256) str; integer sLen, sPos, ePos; logical found; reference(textElement) txPos, txLastPos; % get the text of the string % str := " "; sLen := 0; str( sLen // 1 ) := line( lPos // 1 ); sLen := sLen + 1; lPos := lPos + 1; while lPos <= 255 and line( lPos // 1 ) not = terminator do begin str( sLen // 1 ) := line( lPos // 1 ); sLen := sLen + 1; lPos := lPos + 1 end while_more_string ; if lPos > 255 then rtError( "Unterminated String in node file." ); % attempt to find the text in the list of strings/identifiers % txLastPos := txPos := txList; found := false; ePos := 0; while not found and txPos not = null do begin ePos := ePos + 1; found := ( length(txPos) = sLen ); sPos := 0; while found and sPos < sLen do begin found := str( sPos // 1 ) = text( start(txPos) + sPos ); sPos := sPos + 1 end while_not_found ; txLastPos := txPos; if not found then txPos := next(txPos) end while_string_not_found ; if not found then begin % the string/identifier is not in the list - add it % ePos := ePos + 1; if txList = null then txList := textElement( textNext, sLen, null ) else next(txLastPos) := textElement( textNext, sLen, null ); if textNext + sLen > TEXT_MAX then rtError( "Text space exhausted." ) else begin for cPos := 0 until sLen - 1 do begin text( textNext ) := str( cPos // 1 ); textNext := textNext + 1 end for_cPos end end if_not_found ; ePos end readString ; % gets an integer from the line - no checks for valid digits % integer procedure readInteger ; begin integer n; n := 0; while line( lPos // 1 ) not = " " do begin n := ( n * 10 ) + ( decode( line( lPos // 1 ) ) - decode( "0" ) ); lPos := lPos + 1 end while_not_end_of_integer ; n end readInteger ; string(256) line; string(16) name; integer lPos, tPos, ndType; tPos := lPos := 0; readcard( line ); % get the node type name % while line( lPos // 1 ) = " " do lPos := lPos + 1; name := ""; while lPos < 256 and line( lPos // 1 ) not = " " do begin name( tPos // 1 ) := line( lPos // 1 ); lPos := lPos + 1; tPos := tPos + 1 end while_more_name ; % determine the node type % ndType := 1; resultNode := null; if name not = ";" then begin % not a null node % while ndType <= MAX_NODE_TYPE and name not = ndName( ndType ) do ndType := ndType + 1; if ndType > MAX_NODE_TYPE then rtError( "Malformed node." ); % handle the additional parameter for identifier/string/integer, or sub-nodes for operator nodes % if ndType = nInteger or ndType = nIdentifier or ndType = nString then begin while line( lPos // 1 ) = " " do lPos := lPos + 1; if ndType = nInteger then resultNode := operandNode( ndType, readInteger ) else if ndType = nIdentifier then resultNode := operandNode( ndType, readString( idList, " " ) ) else % ndType = nString % resultNode := operandNode( ndType, readString( stList, """" ) ) end else begin % operator node % reference(node) leftNode; leftNode := readNode; resultNode := opNode( ndType, leftNode, readNode ) end end if_non_null_node ; resultNode end readNode ; % interprets the specified node and returns the value % integer procedure eval ( reference(node) value n ) ; begin integer v; % prints a string from text, escape sequences are interpreted % procedure writeOnText( reference(textElement) value txHead; integer value txNumber ) ; begin reference(textElement) txPos; integer count; txPos := txHead; count := 1; while count < txNumber and txPos not = null do begin txPos := next(txPos); count := count + 1 end while_text_element_not_found ; if txPos = null then rtError( "INTERNAL ERROR: text not found." ) else begin % found the text - output it, handling escape sequences % integer cPos; cPos := 1; % start from 1 to skip over the leading " % while cPos < length(txPos) do begin string(1) ch; ch := text( start(txPos) + cPos ); if ch not = "\" then writeon( s_w := 0, ch ) else begin % escaped character % cPos := cPos + 1; if cPos > length(txPos) then rtError( "String terminates with ""\""." ) else begin ch := text( start(txPos) + cPos ); if ch = "n" then % newline % write() else writeon( s_w := 0, ch ) end end; cPos := cPos + 1 end while_not_end_of_string end end writeOnText ; % returns 1 if val is true, 0 otherwise % integer procedure booleanResult ( logical value val ) ; begin if val then 1 else 0 end booleanResult ; v := 0; if n = null then v := 0 else if type(n) = nIdentifier then v := data( iValue(n) ) else if type(n) = nString then v := iValue(n) else if type(n) = nInteger then v := iValue(n) else if type(n) = nSequence then begin % sequence - evaluate and discard the left branch and return the right branch % v := eval( left(n) ); v := eval( right(n) ) end else if type(n) = nIf then % if-else % begin if eval( left(n) ) not = 0 then v := eval( left(right(n)) ) else v := eval( right(right(n)) ); v := 0 end else if type(n) = nPrtc then % print character % writeon( s_w := 0, code( eval( left(n) ) ) ) else if type(n) = nPrts then % print string % writeOnText( stList, eval( left(n) ) ) else if type(n) = nPrti then % print integer % writeon( s_w := 0, i_w := 1, eval( left(n) ) ) else if type(n) = nWhile then % while-loop % begin while eval( left(n) ) not = 0 do v := eval( right(n) ); v := 0 end else if type(n) = nAssign then % assignment % data( iValue(left(n)) ) := eval( right(n) ) else if type(n) = nNegate then % unary - % v := - eval( left(n) ) else if type(n) = nNot then % unary not % v := booleanResult( eval( left(n) ) = 0 ) else if type(n) = nMultiply then % multiply % v := eval( left(n) ) * eval( right(n) ) else if type(n) = nDivide then % division % begin integer lv, rv; lv := eval( left(n) ); rv := eval( right(n) ); if rv = 0 then rtError( "Division by 0." ) else v := lv div rv end else if type(n) = nMod then % modulo % begin integer lv, rv; lv := eval( left(n) ); rv := eval( right(n) ); if rv = 0 then rtError( "Right operand of % is 0." ) else v := lv rem rv end else if type(n) = nAdd then % addition % v := eval( left(n) ) + eval( right(n) ) else if type(n) = nSubtract then % subtraction % v := eval( left(n) ) - eval( right(n) ) else if type(n) = nLess then % less-than % v := booleanResult( eval( left(n) ) < eval( right(n) ) ) else if type(n) = nLessEqual then % less or equal % v := booleanResult( eval( left(n) ) <= eval( right(n) ) ) else if type(n) = nGreater then % greater-than % v := booleanResult( eval( left(n) ) > eval( right(n) ) ) else if type(n) = nGreaterEqual then % greater or eq % v := booleanResult( eval( left(n) ) >= eval( right(n) ) ) else if type(n) = nEqual then % test equal % v := booleanResult( eval( left(n) ) = eval( right(n) ) ) else if type(n) = nNotEqual then % not-equal % v := booleanResult( eval( left(n) ) not = eval( right(n) ) ) else if type(n) = nAnd then % boolean "and" % begin v := eval( left(n) ); if v not = 0 then v := eval( right(n) ) end else if type(n) = nOr then % boolean "or" % begin v := eval( left(n) ); if v = 0 then v := eval( right(n) ); end else % unknown node % begin rtError( "Unknown node type in eval." ) end; v end eval ; nIdentifier := 1; ndName( nIdentifier ) := "Identifier"; nString := 2; ndName( nString ) := "String"; nInteger := 3; ndName( nInteger ) := "Integer"; nSequence := 4; ndName( nSequence ) := "Sequence"; nIf := 5; ndName( nIf ) := "If"; nPrtc := 6; ndName( nPrtc ) := "Prtc"; nPrts := 7; ndName( nPrts ) := "Prts"; nPrti := 8; ndName( nPrti ) := "Prti"; nWhile := 9; ndName( nWhile ) := "While"; nAssign := 10; ndName( nAssign ) := "Assign"; nNegate := 11; ndName( nNegate ) := "Negate"; nNot := 12; ndName( nNot ) := "Not"; nMultiply := 13; ndName( nMultiply ) := "Multiply"; nDivide := 14; ndName( nDivide ) := "Divide"; nMod := 15; ndName( nMod ) := "Mod"; nAdd := 16; ndName( nAdd ) := "Add"; nSubtract := 17; ndName( nSubtract ) := "Subtract"; nLess := 18; ndName( nLess ) := "Less"; nLessEqual := 19; ndName( nLessEqual ) := "LessEqual" ; nGreater := 20; ndName( nGreater ) := "Greater"; nGreaterEqual := 21; ndName( nGreaterEqual ) := "GreaterEqual"; nEqual := 22; ndName( nEqual ) := "Equal"; nNotEqual := 23; ndName( nNotEqual ) := "NotEqual"; nAnd := 24; ndName( nAnd ) := "And"; nOr := 25; ndName( nOr ) := "Or"; MAX_NODE_TYPE := 25; TEXT_MAX := 4095; textNext := 0; stList := idList := null; % parse the output from the syntax analyser and intetrpret parse tree % eval( readNode ) end.

http://rosettacode.org/wiki/Conway%27s_Game_of_Life

Conway's Game of Life

The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.

#ARM_Assembly

ARM Assembly

.string "PRG" lcd_ptr .req r4 active_fb .req r5 inactive_fb .req r6 offset_r .req r7 backup_fb .req r8 @ start push {r4-r10, r12, lr} ldr lcd_ptr, =0xC0000000 @ address of the LCD controller adr offset_r, offsets ldrh r0, [offset_r, #6] @ 0xffff is already in memory because -1 is in the offsets table str r0, [lcd_ptr, #0x200] @ set up paletted colors: 1 is black, 0 is white ldr r2, [lcd_ptr, #0x18] @ load lcd configuration bic r2, #14 orr r2, #6 @ Set color mode to 8 bpp, paletted str r2, [lcd_ptr, #0x18] ldr backup_fb, [lcd_ptr, #0x10] @ Save address of OS framebuffer @ allocate a buffer for game state / framebuffer ldr r0, =153600 @ 320 * 240 * 2 add r0, #8 svc #5 @ malloc push {r0} orr inactive_fb, r0, #7 add inactive_fb, #1 add active_fb, inactive_fb, #76800 @ fill buffer with random ones and zeroes ldr r10, =76800 mov r9, #0 1: subs r10, r10, #1 strb r9, [active_fb, r10] @ zero other framebuffer svc #206 @ rand syscall and r0, r0, #1 strb r0, [inactive_fb, r10] bne 1b @ set first and last rows to zero mov r2, #320 mov r1, #0 mov r0, inactive_fb push {r1,r2} svc #7 @ memset pop {r1,r2} ldr r3, =76480 add r0, r0, r3 svc #7 @ beginning of main loop, swap framebuffers 3: ldr r0, =76480 @ 320 * 239 str inactive_fb, [lcd_ptr, #0x10] mov inactive_fb, active_fb ldr active_fb, [lcd_ptr, #0x10] @ per-pixel loop 2: mov r1, #16 @ 8 * 2 mov r2, #0 sub r0, #1 @ loop to count up neighboring living cells 1: subs r1, #2 ldrsh r3, [offset_r, r1] @ cant use lsl #1 add r3, r3, r0 ldrb r3, [active_fb, r3] add r2, r2, r3 bne 1b @ at end of loop, r1 and r3 can be discarded @ decides whether the cell should live or die based on neighbors ldrb r1, [active_fb, r0] add r2, r2, r1 teq r2, #3 moveq r1, #1 teqne r2, #4 movne r1, #0 strb r1, [inactive_fb, r0] teq r0, #320 bne 2b @ checks if the escape key is pressed ldr r0, =0x900E001C ldr r1, [r0] tst r1, #0x80 beq 3b str backup_fb, [lcd_ptr, #0x10] @ restores OS framebuffer pop {r0} svc #6 @ free buffer pop {r4-r10, r12, pc} offsets: .hword -321, -320, -319, -1, 1, 319, 320, 321

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Maple

Maple

Point:= Record(x = 2,y = 4): Point:-x; Point:-y;

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Mathematica_.2F_Wolfram_Language

Mathematica / Wolfram Language

In[1]:= a = point[2, 3] Out[1]= point[2, 3] In[2]:= a[[2]] Out[2]= 3 In[3]:= a[[2]] = 4; a Out[3]= point[2, 4]

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Shiny

Shiny

src: 'hello' cpy: src

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Sidef

Sidef

var original = "hello"; # new String object var reference = original; # points at the original object var copy1 = String.new(original); # creates a new String object var copy2 = original+''; # ==//==

http://rosettacode.org/wiki/Constrained_random_points_on_a_circle

Constrained random points on a circle

Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.

#Python

Python

>>> from collections import defaultdict >>> from random import choice >>> world = defaultdict(int) >>> possiblepoints = [(x,y) for x in range(-15,16) for y in range(-15,16) if 10 <= abs(x+y*1j) <= 15] >>> for i in range(100): world[choice(possiblepoints)] += 1 >>> for x in range(-15,16): print(''.join(str(min([9, world[(x,y)]])) if world[(x,y)] else ' ' for y in range(-15,16))) 1 1 1 1 11 1 1 1 1 111 1 1211 1 2 1 1 11 1 11 21 1 1 11 1 1 2 1 1 1 2 1 1 1 1 1 2 11 1 1 1 1 1 1 2 1 1 1 1 1 2 1 1 3 11 2 11 1 1 1 2 1 1 2 1 1 1 1 1 2 2 1 1

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Raven

Raven

[ 'Enjoy' 'Rosetta' 'Code' ] as $words thread talker $words pop "%s\n" repeat dup print 500 choose ms talker as a talker as b talker as c

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Rhope

Rhope

Main(0,0) |: Print["Enjoy"] Print["Rosetta"] Print["Code"] :|

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Ruby

Ruby

%w{Enjoy Rosetta Code}.map do |x| Thread.new do sleep rand puts x end end.each do |t| t.join end

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Tcl

Tcl

proc makeFacExpr n { set exp 1 for {set i 2} {$i <= $n} {incr i} { append exp " * $i" } return "expr \{$exp\}" } eval [makeFacExpr 10]

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Ursala

Ursala

#import nat x = factorial 10 #executable& comcal = ! (%nP x)--<''>

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Visual_Basic_.NET

Visual Basic .NET

Module Program Const FACTORIAL_10 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 Sub Main() Console.WriteLine(FACTORIAL_10) End Sub End Module

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Wren

Wren

var factorial10 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 System.print(factorial10)

http://rosettacode.org/wiki/Conditional_structures

Conditional structures

Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.

#Aikido

Aikido

var x = loggedin ? sessionid : -1

http://rosettacode.org/wiki/Compiler/AST_interpreter

Compiler/AST interpreter

An AST interpreter interprets an Abstract Syntax Tree (AST) produced by a Syntax Analyzer. Task[edit] Take the AST output from the Syntax analyzer task, and interpret it as appropriate. Refer to the Syntax analyzer task for details of the AST. Loading the AST from the syntax analyzer is as simple as (pseudo code) def load_ast() line = readline() # Each line has at least one token line_list = tokenize the line, respecting double quotes text = line_list[0] # first token is always the node type if text == ";" # a terminal node return NULL node_type = text # could convert to internal form if desired # A line with two tokens is a leaf node # Leaf nodes are: Identifier, Integer, String # The 2nd token is the value if len(line_list) > 1 return make_leaf(node_type, line_list[1]) left = load_ast() right = load_ast() return make_node(node_type, left, right) The interpreter algorithm is relatively simple interp(x) if x == NULL return NULL elif x.node_type == Integer return x.value converted to an integer elif x.node_type == Ident return the current value of variable x.value elif x.node_type == String return x.value elif x.node_type == Assign globals[x.left.value] = interp(x.right) return NULL elif x.node_type is a binary operator return interp(x.left) operator interp(x.right) elif x.node_type is a unary operator, return return operator interp(x.left) elif x.node_type == If if (interp(x.left)) then interp(x.right.left) else interp(x.right.right) return NULL elif x.node_type == While while (interp(x.left)) do interp(x.right) return NULL elif x.node_type == Prtc print interp(x.left) as a character, no newline return NULL elif x.node_type == Prti print interp(x.left) as an integer, no newline return NULL elif x.node_type == Prts print interp(x.left) as a string, respecting newlines ("\n") return NULL elif x.node_type == Sequence interp(x.left) interp(x.right) return NULL else error("unknown node type") Notes: Because of the simple nature of our tiny language, Semantic analysis is not needed. Your interpreter should use C like division semantics, for both division and modulus. For division of positive operands, only the non-fractional portion of the result should be returned. In other words, the result should be truncated towards 0. This means, for instance, that 3 / 2 should result in 1. For division when one of the operands is negative, the result should be truncated towards 0. This means, for instance, that 3 / -2 should result in -1. Test program prime.t lex <prime.t | parse | interp /* Simple prime number generator */ count = 1; n = 1; limit = 100; while (n < limit) { k=3; p=1; n=n+2; while ((k*k<=n) && (p)) { p=n/k*k!=n; k=k+2; } if (p) { print(n, " is prime\n"); count = count + 1; } } print("Total primes found: ", count, "\n"); 3 is prime 5 is prime 7 is prime 11 is prime 13 is prime 17 is prime 19 is prime 23 is prime 29 is prime 31 is prime 37 is prime 41 is prime 43 is prime 47 is prime 53 is prime 59 is prime 61 is prime 67 is prime 71 is prime 73 is prime 79 is prime 83 is prime 89 is prime 97 is prime 101 is prime Total primes found: 26 Additional examples Your solution should pass all the test cases above and the additional tests found Here. Reference The C and Python versions can be considered reference implementations. Related Tasks Lexical Analyzer task Syntax Analyzer task Code Generator task Virtual Machine Interpreter task

#C

C

#include <stdlib.h> #include <stdio.h> #include <string.h> #include <stdarg.h> #include <ctype.h> #define da_dim(name, type) type *name = NULL; \ int _qy_ ## name ## _p = 0; \ int _qy_ ## name ## _max = 0 #define da_rewind(name) _qy_ ## name ## _p = 0 #define da_redim(name) do {if (_qy_ ## name ## _p >= _qy_ ## name ## _max) \ name = realloc(name, (_qy_ ## name ## _max += 32) * sizeof(name[0]));} while (0) #define da_append(name, x) do {da_redim(name); name[_qy_ ## name ## _p++] = x;} while (0) #define da_len(name) _qy_ ## name ## _p #define da_add(name) do {da_redim(name); _qy_ ## name ## _p++;} while (0) typedef enum { nd_Ident, nd_String, nd_Integer, nd_Sequence, nd_If, nd_Prtc, nd_Prts, nd_Prti, nd_While, nd_Assign, nd_Negate, nd_Not, nd_Mul, nd_Div, nd_Mod, nd_Add, nd_Sub, nd_Lss, nd_Leq, nd_Gtr, nd_Geq, nd_Eql, nd_Neq, nd_And, nd_Or } NodeType; typedef struct Tree Tree; struct Tree { NodeType node_type; Tree *left; Tree *right; int value; }; // dependency: Ordered by NodeType, must remain in same order as NodeType enum struct { char *enum_text; NodeType node_type; } atr[] = { {"Identifier" , nd_Ident, }, {"String" , nd_String, }, {"Integer" , nd_Integer,}, {"Sequence" , nd_Sequence,}, {"If" , nd_If, }, {"Prtc" , nd_Prtc, }, {"Prts" , nd_Prts, }, {"Prti" , nd_Prti, }, {"While" , nd_While, }, {"Assign" , nd_Assign, }, {"Negate" , nd_Negate, }, {"Not" , nd_Not, }, {"Multiply" , nd_Mul, }, {"Divide" , nd_Div, }, {"Mod" , nd_Mod, }, {"Add" , nd_Add, }, {"Subtract" , nd_Sub, }, {"Less" , nd_Lss, }, {"LessEqual" , nd_Leq, }, {"Greater" , nd_Gtr, }, {"GreaterEqual", nd_Geq, }, {"Equal" , nd_Eql, }, {"NotEqual" , nd_Neq, }, {"And" , nd_And, }, {"Or" , nd_Or, }, }; FILE *source_fp; da_dim(string_pool, const char *); da_dim(global_names, const char *); da_dim(global_values, int); void error(const char *fmt, ... ) { va_list ap; char buf[1000]; va_start(ap, fmt); vsprintf(buf, fmt, ap); printf("error: %s\n", buf); exit(1); } Tree *make_node(NodeType node_type, Tree *left, Tree *right) { Tree *t = calloc(sizeof(Tree), 1); t->node_type = node_type; t->left = left; t->right = right; return t; } Tree *make_leaf(NodeType node_type, int value) { Tree *t = calloc(sizeof(Tree), 1); t->node_type = node_type; t->value = value; return t; } int interp(Tree *x) { /* interpret the parse tree */ if (!x) return 0; switch(x->node_type) { case nd_Integer: return x->value; case nd_Ident: return global_values[x->value]; case nd_String: return x->value; case nd_Assign: return global_values[x->left->value] = interp(x->right); case nd_Add: return interp(x->left) + interp(x->right); case nd_Sub: return interp(x->left) - interp(x->right); case nd_Mul: return interp(x->left) * interp(x->right); case nd_Div: return interp(x->left) / interp(x->right); case nd_Mod: return interp(x->left) % interp(x->right); case nd_Lss: return interp(x->left) < interp(x->right); case nd_Gtr: return interp(x->left) > interp(x->right); case nd_Leq: return interp(x->left) <= interp(x->right); case nd_Eql: return interp(x->left) == interp(x->right); case nd_Neq: return interp(x->left) != interp(x->right); case nd_And: return interp(x->left) && interp(x->right); case nd_Or: return interp(x->left) || interp(x->right); case nd_Negate: return -interp(x->left); case nd_Not: return !interp(x->left); case nd_If: if (interp(x->left)) interp(x->right->left); else interp(x->right->right); return 0; case nd_While: while (interp(x->left)) interp(x->right); return 0; case nd_Prtc: printf("%c", interp(x->left)); return 0; case nd_Prti: printf("%d", interp(x->left)); return 0; case nd_Prts: printf("%s", string_pool[interp(x->left)]); return 0; case nd_Sequence: interp(x->left); interp(x->right); return 0; default: error("interp: unknown tree type %d\n", x->node_type); } return 0; } void init_in(const char fn[]) { if (fn[0] == '\0') source_fp = stdin; else { source_fp = fopen(fn, "r"); if (source_fp == NULL) error("Can't open %s\n", fn); } } NodeType get_enum_value(const char name[]) { for (size_t i = 0; i < sizeof(atr) / sizeof(atr[0]); i++) { if (strcmp(atr[i].enum_text, name) == 0) { return atr[i].node_type; } } error("Unknown token %s\n", name); return -1; } char *read_line(int *len) { static char *text = NULL; static int textmax = 0; for (*len = 0; ; (*len)++) { int ch = fgetc(source_fp); if (ch == EOF || ch == '\n') { if (*len == 0) return NULL; break; } if (*len + 1 >= textmax) { textmax = (textmax == 0 ? 128 : textmax * 2); text = realloc(text, textmax); } text[*len] = ch; } text[*len] = '\0'; return text; } char *rtrim(char *text, int *len) { // remove trailing spaces for (; *len > 0 && isspace(text[*len - 1]); --(*len)) ; text[*len] = '\0'; return text; } int fetch_string_offset(char *st) { int len = strlen(st); st[len - 1] = '\0'; ++st; char *p, *q; p = q = st; while ((*p++ = *q++) != '\0') { if (q[-1] == '\\') { if (q[0] == 'n') { p[-1] = '\n'; ++q; } else if (q[0] == '\\') { ++q; } } } for (int i = 0; i < da_len(string_pool); ++i) { if (strcmp(st, string_pool[i]) == 0) { return i; } } da_add(string_pool); int n = da_len(string_pool) - 1; string_pool[n] = strdup(st); return da_len(string_pool) - 1; } int fetch_var_offset(const char *name) { for (int i = 0; i < da_len(global_names); ++i) { if (strcmp(name, global_names[i]) == 0) return i; } da_add(global_names); int n = da_len(global_names) - 1; global_names[n] = strdup(name); da_append(global_values, 0); return n; } Tree *load_ast() { int len; char *yytext = read_line(&len); yytext = rtrim(yytext, &len); // get first token char *tok = strtok(yytext, " "); if (tok[0] == ';') { return NULL; } NodeType node_type = get_enum_value(tok); // if there is extra data, get it char *p = tok + strlen(tok); if (p != &yytext[len]) { int n; for (++p; isspace(*p); ++p) ; switch (node_type) { case nd_Ident: n = fetch_var_offset(p); break; case nd_Integer: n = strtol(p, NULL, 0); break; case nd_String: n = fetch_string_offset(p); break; default: error("Unknown node type: %s\n", p); } return make_leaf(node_type, n); } Tree *left = load_ast(); Tree *right = load_ast(); return make_node(node_type, left, right); } int main(int argc, char *argv[]) { init_in(argc > 1 ? argv[1] : ""); Tree *x = load_ast(); interp(x); return 0; }

http://rosettacode.org/wiki/Compiler/syntax_analyzer

Compiler/syntax analyzer

A Syntax analyzer transforms a token stream (from the Lexical analyzer) into a Syntax tree, based on a grammar. Task[edit] Take the output from the Lexical analyzer task, and convert it to an Abstract Syntax Tree (AST), based on the grammar below. The output should be in a flattened format. The program should read input from a file and/or stdin, and write output to a file and/or stdout. If the language being used has a parser module/library/class, it would be great if two versions of the solution are provided: One without the parser module, and one with. Grammar The simple programming language to be analyzed is more or less a (very tiny) subset of C. The formal grammar in Extended Backus-Naur Form (EBNF): stmt_list = {stmt} ; stmt = ';' | Identifier '=' expr ';' | 'while' paren_expr stmt | 'if' paren_expr stmt ['else' stmt] | 'print' '(' prt_list ')' ';' | 'putc' paren_expr ';' | '{' stmt_list '}' ; paren_expr = '(' expr ')' ; prt_list = (string | expr) {',' (String | expr)} ; expr = and_expr {'||' and_expr} ; and_expr = equality_expr {'&&' equality_expr} ; equality_expr = relational_expr [('==' | '!=') relational_expr] ; relational_expr = addition_expr [('<' | '<=' | '>' | '>=') addition_expr] ; addition_expr = multiplication_expr {('+' | '-') multiplication_expr} ; multiplication_expr = primary {('*' | '/' | '%') primary } ; primary = Identifier | Integer | '(' expr ')' | ('+' | '-' | '!') primary ; The resulting AST should be formulated as a Binary Tree. Example - given the simple program (below), stored in a file called while.t, create the list of tokens, using one of the Lexical analyzer solutions lex < while.t > while.lex Run one of the Syntax analyzer solutions parse < while.lex > while.ast The following table shows the input to lex, lex output, and the AST produced by the parser Input to lex Output from lex, input to parse Output from parse count = 1; while (count < 10) { print("count is: ", count, "\n"); count = count + 1; } 1 1 Identifier count 1 7 Op_assign 1 9 Integer 1 1 10 Semicolon 2 1 Keyword_while 2 7 LeftParen 2 8 Identifier count 2 14 Op_less 2 16 Integer 10 2 18 RightParen 2 20 LeftBrace 3 5 Keyword_print 3 10 LeftParen 3 11 String "count is: " 3 23 Comma 3 25 Identifier count 3 30 Comma 3 32 String "\n" 3 36 RightParen 3 37 Semicolon 4 5 Identifier count 4 11 Op_assign 4 13 Identifier count 4 19 Op_add 4 21 Integer 1 4 22 Semicolon 5 1 RightBrace 6 1 End_of_input Sequence Sequence ; Assign Identifier count Integer 1 While Less Identifier count Integer 10 Sequence Sequence ; Sequence Sequence Sequence ; Prts String "count is: " ; Prti Identifier count ; Prts String "\n" ; Assign Identifier count Add Identifier count Integer 1 Specifications List of node type names Identifier String Integer Sequence If Prtc Prts Prti While Assign Negate Not Multiply Divide Mod Add Subtract Less LessEqual Greater GreaterEqual Equal NotEqual And Or In the text below, Null/Empty nodes are represented by ";". Non-terminal (internal) nodes For Operators, the following nodes should be created: Multiply Divide Mod Add Subtract Less LessEqual Greater GreaterEqual Equal NotEqual And Or For each of the above nodes, the left and right sub-nodes are the operands of the respective operation. In pseudo S-Expression format: (Operator expression expression) Negate, Not For these node types, the left node is the operand, and the right node is null. (Operator expression ;) Sequence - sub-nodes are either statements or Sequences. If - left node is the expression, the right node is If node, with it's left node being the if-true statement part, and the right node being the if-false (else) statement part. (If expression (If statement else-statement)) If there is not an else, the tree becomes: (If expression (If statement ;)) Prtc (Prtc (expression) ;) Prts (Prts (String "the string") ;) Prti (Prti (Integer 12345) ;) While - left node is the expression, the right node is the statement. (While expression statement) Assign - left node is the left-hand side of the assignment, the right node is the right-hand side of the assignment. (Assign Identifier expression) Terminal (leaf) nodes: Identifier: (Identifier ident_name) Integer: (Integer 12345) String: (String "Hello World!") ";": Empty node Some simple examples Sequences denote a list node; they are used to represent a list. semicolon's represent a null node, e.g., the end of this path. This simple program: a=11; Produces the following AST, encoded as a binary tree: Under each non-leaf node are two '|' lines. The first represents the left sub-node, the second represents the right sub-node: (1) Sequence (2) |-- ; (3) |-- Assign (4) |-- Identifier: a (5) |-- Integer: 11 In flattened form: (1) Sequence (2) ; (3) Assign (4) Identifier a (5) Integer 11 This program: a=11; b=22; c=33; Produces the following AST: ( 1) Sequence ( 2) |-- Sequence ( 3) | |-- Sequence ( 4) | | |-- ; ( 5) | | |-- Assign ( 6) | | |-- Identifier: a ( 7) | | |-- Integer: 11 ( 8) | |-- Assign ( 9) | |-- Identifier: b (10) | |-- Integer: 22 (11) |-- Assign (12) |-- Identifier: c (13) |-- Integer: 33 In flattened form: ( 1) Sequence ( 2) Sequence ( 3) Sequence ( 4) ; ( 5) Assign ( 6) Identifier a ( 7) Integer 11 ( 8) Assign ( 9) Identifier b (10) Integer 22 (11) Assign (12) Identifier c (13) Integer 33 Pseudo-code for the parser. Uses Precedence Climbing for expression parsing, and Recursive Descent for statement parsing. The AST is also built: def expr(p) if tok is "(" x = paren_expr() elif tok in ["-", "+", "!"] gettok() y = expr(precedence of operator) if operator was "+" x = y else x = make_node(operator, y) elif tok is an Identifier x = make_leaf(Identifier, variable name) gettok() elif tok is an Integer constant x = make_leaf(Integer, integer value) gettok() else error() while tok is a binary operator and precedence of tok >= p save_tok = tok gettok() q = precedence of save_tok if save_tok is not right associative q += 1 x = make_node(Operator save_tok represents, x, expr(q)) return x def paren_expr() expect("(") x = expr(0) expect(")") return x def stmt() t = NULL if accept("if") e = paren_expr() s = stmt() t = make_node(If, e, make_node(If, s, accept("else") ? stmt() : NULL)) elif accept("putc") t = make_node(Prtc, paren_expr()) expect(";") elif accept("print") expect("(") repeat if tok is a string e = make_node(Prts, make_leaf(String, the string)) gettok() else e = make_node(Prti, expr(0)) t = make_node(Sequence, t, e) until not accept(",") expect(")") expect(";") elif tok is ";" gettok() elif tok is an Identifier v = make_leaf(Identifier, variable name) gettok() expect("=") t = make_node(Assign, v, expr(0)) expect(";") elif accept("while") e = paren_expr() t = make_node(While, e, stmt() elif accept("{") while tok not equal "}" and tok not equal end-of-file t = make_node(Sequence, t, stmt()) expect("}") elif tok is end-of-file pass else error() return t def parse() t = NULL gettok() repeat t = make_node(Sequence, t, stmt()) until tok is end-of-file return t Once the AST is built, it should be output in a flattened format. This can be as simple as the following def prt_ast(t) if t == NULL print(";\n") else print(t.node_type) if t.node_type in [Identifier, Integer, String] # leaf node print the value of the Ident, Integer or String, "\n" else print("\n") prt_ast(t.left) prt_ast(t.right) If the AST is correctly built, loading it into a subsequent program should be as simple as def load_ast() line = readline() # Each line has at least one token line_list = tokenize the line, respecting double quotes text = line_list[0] # first token is always the node type if text == ";" # a terminal node return NULL node_type = text # could convert to internal form if desired # A line with two tokens is a leaf node # Leaf nodes are: Identifier, Integer, String # The 2nd token is the value if len(line_list) > 1 return make_leaf(node_type, line_list[1]) left = load_ast() right = load_ast() return make_node(node_type, left, right) Finally, the AST can also be tested by running it against one of the AST Interpreter solutions. Test program, assuming this is in a file called prime.t lex <prime.t | parse Input to lex Output from lex, input to parse Output from parse /* Simple prime number generator */ count = 1; n = 1; limit = 100; while (n < limit) { k=3; p=1; n=n+2; while ((k*k<=n) && (p)) { p=n/k*k!=n; k=k+2; } if (p) { print(n, " is prime\n"); count = count + 1; } } print("Total primes found: ", count, "\n"); 4 1 Identifier count 4 7 Op_assign 4 9 Integer 1 4 10 Semicolon 5 1 Identifier n 5 3 Op_assign 5 5 Integer 1 5 6 Semicolon 6 1 Identifier limit 6 7 Op_assign 6 9 Integer 100 6 12 Semicolon 7 1 Keyword_while 7 7 LeftParen 7 8 Identifier n 7 10 Op_less 7 12 Identifier limit 7 17 RightParen 7 19 LeftBrace 8 5 Identifier k 8 6 Op_assign 8 7 Integer 3 8 8 Semicolon 9 5 Identifier p 9 6 Op_assign 9 7 Integer 1 9 8 Semicolon 10 5 Identifier n 10 6 Op_assign 10 7 Identifier n 10 8 Op_add 10 9 Integer 2 10 10 Semicolon 11 5 Keyword_while 11 11 LeftParen 11 12 LeftParen 11 13 Identifier k 11 14 Op_multiply 11 15 Identifier k 11 16 Op_lessequal 11 18 Identifier n 11 19 RightParen 11 21 Op_and 11 24 LeftParen 11 25 Identifier p 11 26 RightParen 11 27 RightParen 11 29 LeftBrace 12 9 Identifier p 12 10 Op_assign 12 11 Identifier n 12 12 Op_divide 12 13 Identifier k 12 14 Op_multiply 12 15 Identifier k 12 16 Op_notequal 12 18 Identifier n 12 19 Semicolon 13 9 Identifier k 13 10 Op_assign 13 11 Identifier k 13 12 Op_add 13 13 Integer 2 13 14 Semicolon 14 5 RightBrace 15 5 Keyword_if 15 8 LeftParen 15 9 Identifier p 15 10 RightParen 15 12 LeftBrace 16 9 Keyword_print 16 14 LeftParen 16 15 Identifier n 16 16 Comma 16 18 String " is prime\n" 16 31 RightParen 16 32 Semicolon 17 9 Identifier count 17 15 Op_assign 17 17 Identifier count 17 23 Op_add 17 25 Integer 1 17 26 Semicolon 18 5 RightBrace 19 1 RightBrace 20 1 Keyword_print 20 6 LeftParen 20 7 String "Total primes found: " 20 29 Comma 20 31 Identifier count 20 36 Comma 20 38 String "\n" 20 42 RightParen 20 43 Semicolon 21 1 End_of_input Sequence Sequence Sequence Sequence Sequence ; Assign Identifier count Integer 1 Assign Identifier n Integer 1 Assign Identifier limit Integer 100 While Less Identifier n Identifier limit Sequence Sequence Sequence Sequence Sequence ; Assign Identifier k Integer 3 Assign Identifier p Integer 1 Assign Identifier n Add Identifier n Integer 2 While And LessEqual Multiply Identifier k Identifier k Identifier n Identifier p Sequence Sequence ; Assign Identifier p NotEqual Multiply Divide Identifier n Identifier k Identifier k Identifier n Assign Identifier k Add Identifier k Integer 2 If Identifier p If Sequence Sequence ; Sequence Sequence ; Prti Identifier n ; Prts String " is prime\n" ; Assign Identifier count Add Identifier count Integer 1 ; Sequence Sequence Sequence ; Prts String "Total primes found: " ; Prti Identifier count ; Prts String "\n" ; Additional examples Your solution should pass all the test cases above and the additional tests found Here. Reference The C and Python versions can be considered reference implementations. Related Tasks Lexical Analyzer task Code Generator task Virtual Machine Interpreter task AST Interpreter task

#ALGOL_W

ALGOL W

begin % syntax analyser % % parse tree nodes % record node( integer type ; reference(node) left, right ; integer iValue % nString/nIndentifier number or nInteger value % ); integer nIdentifier, nString, nInteger, nSequence, nIf, nPrtc, nPrts , nPrti, nWhile, nAssign, nNegate, nNot, nMultiply , nDivide, nMod, nAdd, nSubtract, nLess, nLessEqual , nGreater, nGreaterEqual, nEqual, nNotEqual, nAnd, nOr ; string(14) array ndName ( 1 :: 25 ); % tokens - names must match those output by the lexical analyser % integer tkType, tkLine, tkColumn, tkLength, tkIntegerValue; integer tOp_multiply , tOp_divide , tOp_mod , tOp_add , tOp_subtract , tOp_negate , tOp_less , tOp_lessequal , tOp_greater , tOp_greaterequal , tOp_equal , tOp_notequal , tOp_not , tOp_assign , tOp_and , tOp_or , tLeftParen , tRightParen , tLeftBrace , tRightBrace , tSemicolon , tComma , tKeyword_if , tKeyword_else , tKeyword_while , tKeyword_print , tKeyword_putc , tIdentifier , tInteger , tString , tEnd_of_input , MAX_TOKEN_TYPE, PRIMARY_PREC ; string(16) array tkName ( 1 :: 31 ); integer array tkPrec, tkNode ( 1 :: 31 ); % string literals and identifiers - uses a linked list - a hash table might be better... % string(1) array text ( 0 :: 4095 ); integer textNext, TEXT_MAX; record textElement ( integer start, length; reference(textElement) next ); reference(textElement) idList, stList; % returns a new node with left and right branches % reference(node) procedure opNode ( integer value opType; reference(node) value opLeft, opRight ) ; begin node( opType, opLeft, opRight, 0 ) end opNode ; % returns a new operand node % reference(node) procedure operandNode ( integer value opType, opValue ) ; begin node( opType, null, null, opValue ) end operandNode ; % reports an error % procedure synError( integer value line, column; string(80) value message ); begin integer errorPos; write( i_w := 1, s_w := 0, "**** Error at(", line, ",", column, "): " ); errorPos := 0; while errorPos < 80 and message( errorPos // 1 ) not = "." do begin writeon( s_w := 0, message( errorPos // 1 ) ); errorPos := errorPos + 1 end while_not_at_end_of_message ; writeon( s_w := 0, "." ) end synError ; % reports an error and stops % procedure fatalError( integer value line, column; string(80) value message ); begin synError( line, column, message ); assert( false ) end fatalError ; % prints a node and its sub-nodes % procedure writeNode( reference(node) value n ) ; begin % prints an identifier or string from text % procedure writeOnText( reference(textElement) value txHead; integer value txNumber ) ; begin reference(textElement) txPos; integer count; txPos := txHead; count := 1; while count < txNumber and txPos not = null do begin txPos := next(txPos); count := count + 1 end while_text_element_not_found ; if txPos = null then fatalError( 0, txNumber, "INTERNAL ERROR: text not found." ) else for cPos := 0 until length(txPos) - 1 do writeon( text( start(txPos) + cPos ) ); if text( start(txPos) ) = """" then writeon( """" ); end writeOnText ; if n = null then write( ";" ) else begin write( ndName( type(n) ) ); if type(n) = nInteger then writeon( iValue(n) ) else if type(n) = nIdentifier then writeOnText( idList, iValue(n) ) else if type(n) = nString then writeOnText( stList, iValue(n) ) else begin writeNode( left(n) ); writeNode( right(n) ) end end end writeNode ; % reads a token from standard input % procedure readToken ; begin % parses a string from line and stores it in a string in the text array % % - if it is not already present in the specified textElement list. % % returns the position of the string in the text array % integer procedure readString ( reference(textElement) value result txList; string(1) value terminator ) ; begin string(256) str; integer sLen, sPos, ePos; logical found; reference(textElement) txPos, txLastPos; % get the text of the string % str := " "; sLen := 0; str( sLen // 1 ) := line( lPos // 1 ); sLen := sLen + 1; lPos := lPos + 1; while lPos <= 255 and line( lPos // 1 ) not = terminator do begin str( sLen // 1 ) := line( lPos // 1 ); sLen := sLen + 1; lPos := lPos + 1 end while_more_string ; if lPos > 255 then fatalError( tkLine, tkColumn, "Unterminated String in token file." ); % attempt to find the text in the list of strings/identifiers % txLastPos := txPos := txList; found := false; ePos := 0; while not found and txPos not = null do begin ePos := ePos + 1; found := ( length(txPos) = sLen ); sPos := 0; while found and sPos < sLen do begin found := str( sPos // 1 ) = text( start(txPos) + sPos ); sPos := sPos + 1 end while_not_found ; txLastPos := txPos; if not found then txPos := next(txPos) end while_string_not_found ; if not found then begin % the string/identifier is not in the list - add it % ePos := ePos + 1; if txList = null then txList := textElement( textNext, sLen, null ) else next(txLastPos) := textElement( textNext, sLen, null ); if textNext + sLen > TEXT_MAX then fatalError( tkLine, tkColumn, "Text space exhausted." ) else begin for cPos := 0 until sLen - 1 do begin text( textNext ) := str( cPos // 1 ); textNext := textNext + 1 end for_cPos end end if_not_found ; ePos end readString ; % gets an integer from the line - no checks for valid digits % integer procedure readInteger ; begin integer n; while line( lPos // 1 ) = " " do lPos := lPos + 1; n := 0; while line( lPos // 1 ) not = " " do begin n := ( n * 10 ) + ( decode( line( lPos // 1 ) ) - decode( "0" ) ); lPos := lPos + 1 end while_not_end_of_integer ; n end readInteger ; string(256) line; string(16) name; integer lPos, tPos; tPos := lPos := 0; readcard( line ); % get the line and column numbers % tkLine := readInteger; tkColumn := readInteger; % get the token name % while line( lPos // 1 ) = " " do lPos := lPos + 1; name := ""; while lPos < 256 and line( lPos // 1 ) not = " " do begin name( tPos // 1 ) := line( lPos // 1 ); lPos := lPos + 1; tPos := tPos + 1 end while_more_name ; % determine the token type % tkType := 1; tkIntegerValue := 0; while tkType <= MAX_TOKEN_TYPE and name not = tkName( tkType ) do tkType := tkType + 1; if tkType > MAX_TOKEN_TYPE then fatalError( tkLine, tkColumn, "Malformed token" ); % handle the additional parameter for identifier/string/integer % if tkType = tInteger or tkType = tIdentifier or tkType = tString then begin while line( lPos // 1 ) = " " do lPos := lPos + 1; if tkType = tInteger then tkIntegerValue := readInteger else if tkType = tIdentifier then tkIntegerValue := readString( idList, " " ) else % tkType = tString % tkIntegerValue := readString( stList, """" ) end if_token_with_additional_parameter ; end readToken ; % parses a statement % reference(node) procedure parseStatement ; begin reference(node) stmtNode, stmtExpr; % skips the current token if it is expectedToken, % % returns true if the token was expectedToken, false otherwise % logical procedure have ( integer value expectedToken ) ; begin logical haveExpectedToken; haveExpectedToken := ( tkType = expectedToken ); if haveExpectedToken and tkType not = tEnd_of_input then readToken; haveExpectedToken end have ; % issues an error message and skips past the next semi-colon or to end of input % procedure skipStatement ( string(80) value message ) ; begin synError( tkLine, tkColumn, message ); while tkType not = tEnd_of_input and not have( tSemicolon ) do readToken end skipStatement ; % checks we have a semicolon, issues an error and skips the statement if not % procedure mustBeEndOfStatement ; begin if not have( tSemicolon ) then skipStatement( """;"" expected." ) end mustBeEndOfStatement ; % skips the current token if it is "(" and issues an error if it isn't % procedure mustBeLeftParen ; begin if not have( tLeftParen ) then synError( tkLine, tkColumn, """("" expected." ) end % mustBeLeftParen % ; % skips the current token if it is ")" and issues an error if it isn't % procedure mustBeRightParen ; begin if not have( tRightParen ) then synError( tkLine, tkColumn, """)"" expected." ) end % mustBeRightParen % ; % gets the next token and parses an expression with the specified precedence % reference(node) procedure nextAndparseExpr ( integer value precedence ) ; begin readToken; parseExpr( precedence ) end nextAndParseExpr ; % parses an expression with the specified precedence % % all operators are assumed to be left-associative % reference(node) procedure parseExpr ( integer value precedence ) ; begin % handles a single token primary % reference(node) procedure simplePrimary ( integer value primaryNodeType ) ; begin reference(node) primaryNode; primaryNode := operandNode( primaryNodeType, tkIntegerValue ); readToken; primaryNode end simplePrimary ; reference(node) exprNode; if precedence < PRIMARY_PREC then begin exprNode := parseExpr( precedence + 1 ); while tkPrec( tkType ) = precedence do begin integer op; op := tkNode( tkType ); exprNode := opNode( op, exprNode, nextAndParseExpr( precedence + 1 ) ) end while_op_at_this_precedence_level end else if tkType = tIdentifier then exprNode := simplePrimary( nIdentifier ) else if tkType = tInteger then exprNode := simplePrimary( nInteger ) else if tkType = nString then begin synError( tkLine, tkColumn, "Unexpected string literal." ); exprNode := simplePrimary( nInteger ) end else if tkType = tLeftParen then exprNode := parseParenExpr else if tkType = tOp_add then exprNode := nextAndParseExpr( precedence ) else if tkType = tOp_subtract then exprNode := opNode( nNegate, nextAndParseExpr( precedence ), null ) else if tkType = tOp_not then exprNode := opNode( nNot, nextAndParseExpr( precedence ), null ) else begin synError( tkLine, tkColumn, "Syntax error in expression." ); exprNode := simplePrimary( nInteger ) end; exprNode end parseExpr ; % parses a preenthesised expression % reference(node) procedure parseParenExpr ; begin reference(node) exprNode; mustBeLeftParen; exprNode := parseExpr( 0 ); mustBeRightParen; exprNode end parseParenExpr ; % parse statement depending on it's first token % if tkType = tIdentifier then begin % assignment statement % stmtExpr := operandNode( nIdentifier, tkIntegerValue ); % skip the identifier and check for "=" % readToken; if not have( tOp_Assign ) then synError( tkLine, tkColumn, "Expected ""="" in assignment statement." ); stmtNode := opNode( nAssign, stmtExpr, parseExpr( 0 ) ); mustBeEndOfStatement end else if have( tKeyword_while ) then begin stmtExpr := parseParenExpr; stmtNode := opNode( nWhile, stmtExpr, parseStatement ) end else if have( tkeyword_if ) then begin stmtExpr := parseParenExpr; stmtNode := opNode( nIf, stmtExpr, opNode( nIf, parseStatement, null ) ); if have( tKeyword_else ) then % have an "else" part % right(right(stmtNode)) := parseStatement end else if have( tKeyword_Print ) then begin mustBeLeftParen; stmtNode := null; while begin if tkType = tString then begin stmtNode := opNode( nSequence, stmtNode, opNode( nPrts, operandNode( nString, tkIntegerValue ), null ) ); readToken end else stmtNode := opNode( nSequence, stmtNode, opNode( nPrti, parseExpr( 0 ), null ) ); have( tComma ) end do begin end; mustBeRightparen; mustBeEndOfStatement; end else if have( tKeyword_Putc ) then begin stmtNode := opNode( nPrtc, parseParenExpr, null ); mustBeEndOfStatement end else if have( tLeftBrace ) then begin % block % stmtNode := parseStatementList( tRightBrace ); if not have( tRightBrace ) then synError( tkLine, tkColumn, "Expected ""}""." ); end else if have( tSemicolon ) then stmtNode := null else begin % unrecognised statement % skipStatement( "Unrecognised statement." ); stmtNode := null end if_various_tokens ; stmtNode end parseStatement ; % parses a statement list ending with the specified terminator % reference(node) procedure parseStatementList ( integer value terminator ) ; begin reference(node) listNode; listNode := null; while tkType not = terminator and tkType not = tEnd_of_input do listNode := opNode( nSequence, listNode, parseStatement ); listNode end parseStatementList ; nIdentifier := 1; ndName( nIdentifier ) := "Identifier"; nString := 2; ndName( nString ) := "String"; nInteger := 3; ndName( nInteger ) := "Integer"; nSequence := 4; ndName( nSequence ) := "Sequence"; nIf := 5; ndName( nIf ) := "If"; nPrtc := 6; ndName( nPrtc ) := "Prtc"; nPrts := 7; ndName( nPrts ) := "Prts"; nPrti := 8; ndName( nPrti ) := "Prti"; nWhile := 9; ndName( nWhile ) := "While"; nAssign := 10; ndName( nAssign ) := "Assign"; nNegate := 11; ndName( nNegate ) := "Negate"; nNot := 12; ndName( nNot ) := "Not"; nMultiply := 13; ndName( nMultiply ) := "Multiply"; nDivide := 14; ndName( nDivide ) := "Divide"; nMod := 15; ndName( nMod ) := "Mod"; nAdd := 16; ndName( nAdd ) := "Add"; nSubtract := 17; ndName( nSubtract ) := "Subtract"; nLess := 18; ndName( nLess ) := "Less"; nLessEqual := 19; ndName( nLessEqual ) := "LessEqual" ; nGreater := 20; ndName( nGreater ) := "Greater"; nGreaterEqual := 21; ndName( nGreaterEqual ) := "GreaterEqual"; nEqual := 22; ndName( nEqual ) := "Equal"; nNotEqual := 23; ndName( nNotEqual ) := "NotEqual"; nAnd := 24; ndName( nAnd ) := "And"; nOr := 25; ndName( nOr ) := "Or"; tOp_multiply := 1; tkName( tOp_multiply ) := "Op_multiply"; tkPrec( tOp_multiply ) := 5; tOp_divide := 2; tkName( tOp_divide ) := "Op_divide"; tkPrec( tOp_divide ) := 5; tOp_mod := 3; tkName( tOp_mod ) := "Op_mod"; tkPrec( tOp_mod ) := 5; tOp_add := 4; tkName( tOp_add ) := "Op_add"; tkPrec( tOp_add ) := 4; tOp_subtract := 5; tkName( tOp_subtract ) := "Op_subtract"; tkPrec( tOp_subtract ) := 4; tOp_negate := 6; tkName( tOp_negate ) := "Op_negate"; tkPrec( tOp_negate ) := -1; tOp_less := 7; tkName( tOp_less ) := "Op_less"; tkPrec( tOp_less ) := 3; tOp_lessequal := 8; tkName( tOp_lessequal ) := "Op_lessequal"; tkPrec( tOp_lessequal ) := 3; tOp_greater := 9; tkName( tOp_greater ) := "Op_greater"; tkPrec( tOp_greater ) := 3; tOp_greaterequal := 10; tkName( tOp_greaterequal ) := "Op_greaterequal"; tkPrec( tOp_greaterequal ) := 3; tOp_equal := 11; tkName( tOp_equal ) := "Op_equal"; tkPrec( tOp_equal ) := 2; tOp_notequal := 12; tkName( tOp_notequal ) := "Op_notequal"; tkPrec( tOp_notequal ) := 2; tOp_not := 13; tkName( tOp_not ) := "Op_not"; tkPrec( tOp_not ) := -1; tOp_assign := 14; tkName( tOp_assign ) := "Op_assign"; tkPrec( tOp_assign ) := -1; tOp_and := 15; tkName( tOp_and ) := "Op_and"; tkPrec( tOp_and ) := 1; tOp_or := 16; tkName( tOp_or ) := "Op_or"; tkPrec( tOp_or ) := 0; tLeftParen := 17; tkName( tLeftParen ) := "LeftParen"; tkPrec( tLeftParen ) := -1; tRightParen := 18; tkName( tRightParen ) := "RightParen"; tkPrec( tRightParen ) := -1; tLeftBrace := 19; tkName( tLeftBrace ) := "LeftBrace"; tkPrec( tLeftBrace ) := -1; tRightBrace := 20; tkName( tRightBrace ) := "RightBrace"; tkPrec( tRightBrace ) := -1; tSemicolon := 21; tkName( tSemicolon ) := "Semicolon"; tkPrec( tSemicolon ) := -1; tComma := 22; tkName( tComma ) := "Comma"; tkPrec( tComma ) := -1; tKeyword_if := 23; tkName( tKeyword_if ) := "Keyword_if"; tkPrec( tKeyword_if ) := -1; tKeyword_else := 24; tkName( tKeyword_else ) := "Keyword_else"; tkPrec( tKeyword_else ) := -1; tKeyword_while := 25; tkName( tKeyword_while ) := "Keyword_while"; tkPrec( tKeyword_while ) := -1; tKeyword_print := 26; tkName( tKeyword_print ) := "Keyword_print"; tkPrec( tKeyword_print ) := -1; tKeyword_putc := 27; tkName( tKeyword_putc ) := "Keyword_putc"; tkPrec( tKeyword_putc ) := -1; tIdentifier := 28; tkName( tIdentifier ) := "Identifier"; tkPrec( tIdentifier ) := -1; tInteger := 29; tkName( tInteger ) := "Integer"; tkPrec( tInteger ) := -1; tString := 30; tkName( tString ) := "String"; tkPrec( tString ) := -1; tEnd_of_input := 31; tkName( tEnd_of_input ) := "End_of_input"; tkPrec( tEnd_of_input ) := -1; MAX_TOKEN_TYPE := 31; TEXT_MAX := 4095; textNext := 0; PRIMARY_PREC := 6; for tkPos := 1 until MAX_TOKEN_TYPE do tkNode( tkPos ) := - tkPos; tkNode( tOp_multiply ) := nMultiply; tkNode( tOp_divide ) := nDivide; tkNode( tOp_mod ) := nMod; tkNode( tOp_add ) := nAdd; tkNode( tOp_subtract ) := nSubtract; tkNode( tOp_less ) := nLess; tkNode( tOp_lessequal ) := nLessEqual; tkNode( tOp_greater ) := nGreater; tkNode( tOp_greaterequal ) := nGreaterEqual; tkNode( tOp_equal ) := nEqual; tkNode( tOp_notequal ) := nNotEqual; tkNode( tOp_not ) := nNot; tkNode( tOp_and ) := nAnd; tkNode( tOp_or ) := nOr; stList := idList := null; % parse the output from the lexical analyser and output the linearised parse tree % readToken; writeNode( parseStatementList( tEnd_of_input ) ) end.

http://rosettacode.org/wiki/Conway%27s_Game_of_Life

Conway's Game of Life

The Game of Life is a cellular automaton devised by the British mathematician John Horton Conway in 1970. It is the best-known example of a cellular automaton. Conway's game of life is described here: A cell C is represented by a 1 when alive, or 0 when dead, in an m-by-m (or m×m) square array of cells. We calculate N - the sum of live cells in C's eight-location neighbourhood, then cell C is alive or dead in the next generation based on the following table: C N new C 1 0,1 -> 0 # Lonely 1 4,5,6,7,8 -> 0 # Overcrowded 1 2,3 -> 1 # Lives 0 3 -> 1 # It takes three to give birth! 0 0,1,2,4,5,6,7,8 -> 0 # Barren Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Task Although you should test your implementation on more complex examples such as the glider in a larger universe, show the action of the blinker (three adjoining cells in a row all alive), over three generations, in a 3 by 3 grid. References Its creator John Conway, explains the game of life. Video from numberphile on youtube. John Conway Inventing Game of Life - Numberphile video. Related task Langton's ant - another well known cellular automaton.

#AutoHotkey

AutoHotkey

rows := cols := 10 ; set grid dimensions i = -1,0,1, -1,1, -1,0,1 ; neighbors' x-offsets j = -1,-1,-1, 0,0, 1,1,1 ; neighbors' y-offsets StringSplit i, i, `, ; make arrays StringSplit j, j, `, Loop % rows { ; setup grid of checkboxes r := A_Index, y := r*17-8 ; looks good in VISTA Loop % cols { c := A_Index, x := c*17-5 Gui Add, CheckBox, x%x% y%y% w17 h17 vv%c%_%r% gCheck } } Gui Add, Button, % "x12 w" x+2, step ; button to step to next generation Gui Show Return Check: GuiControlGet %A_GuiControl% ; manual set of cells Return ButtonStep: ; move to next generation Loop % rows { r := A_Index Loop % cols { c := A_Index, n := 0 Loop 8 ; w[x,y] <- new states x := c+i%A_Index%, y := r+j%A_Index%, n += 1=v%x%_%y% GuiControl,,v%c%_%r%,% w%c%_%r% := v%c%_%r% ? n=2 || n=3 : n=3 } } Loop % rows { ; update v[x,y] = states r := A_Index Loop % cols v%A_Index%_%r% := w%A_Index%_%r% } Return GuiClose: ; exit when GUI is closed ExitApp

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#MATLAB_.2F_Octave

MATLAB / Octave

point.x=3; point.y=4;

http://rosettacode.org/wiki/Compound_data_type

Compound data type

Data Structure This illustrates a data structure, a means of storing data within a program. You may see other such structures in the Data Structures category. Task Create a compound data type: Point(x,y) A compound data type is one that holds multiple independent values. Related task Enumeration See also Array Associative array: Creation, Iteration Collections Compound data type Doubly-linked list: Definition, Element definition, Element insertion, List Traversal, Element Removal Linked list Queue: Definition, Usage Set Singly-linked list: Element definition, Element insertion, List Traversal, Element Removal Stack

#Maxima

Maxima

defstruct(point(x, y))$ p: new(point)$ q: point(1, 2)$ p@x: 5$

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Simula

Simula

BEGIN TEXT ORIGINAL, REFERENCE, COPY1; ORIGINAL :- "THIS IS CONSTANT TEXT"; ORIGINAL.SETPOS(1); REFERENCE :- ORIGINAL; ! RUN TIME ERROR: ! ORIGINAL.PUTCHAR('X'); ! "copy-a-string.sim", line 9: ./copy-a-string: Putchar: Constant text object ; OUTTEXT(ORIGINAL); OUTIMAGE; ! CONTENT EQUAL? => T ; OUTTEXT(IF ORIGINAL = REFERENCE THEN "T" ELSE "F"); OUTIMAGE; ! SAME TEXT OBJECT? => T ; OUTTEXT(IF ORIGINAL == REFERENCE THEN "T" ELSE "F"); OUTIMAGE; COPY1 :- COPY(ORIGINAL); COPY1.SETPOS(1); COPY1.PUTCHAR('X'); OUTTEXT(COPY1); OUTIMAGE; END;

http://rosettacode.org/wiki/Copy_a_string

Copy a string

This task is about copying a string. Task Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string. Other tasks related to string operations: Metrics Array length String length Copy a string Empty string (assignment) Counting Word frequency Letter frequency Jewels and stones I before E except after C Bioinformatics/base count Count occurrences of a substring Count how many vowels and consonants occur in a string Remove/replace XXXX redacted Conjugate a Latin verb Remove vowels from a string String interpolation (included) Strip block comments Strip comments from a string Strip a set of characters from a string Strip whitespace from a string -- top and tail Strip control codes and extended characters from a string Anagrams/Derangements/shuffling Word wheel ABC problem Sattolo cycle Knuth shuffle Ordered words Superpermutation minimisation Textonyms (using a phone text pad) Anagrams Anagrams/Deranged anagrams Permutations/Derangements Find/Search/Determine ABC words Odd words Word ladder Semordnilap Word search Wordiff (game) String matching Tea cup rim text Alternade words Changeable words State name puzzle String comparison Unique characters Unique characters in each string Extract file extension Levenshtein distance Palindrome detection Common list elements Longest common suffix Longest common prefix Compare a list of strings Longest common substring Find common directory path Words from neighbour ones Change e letters to i in words Non-continuous subsequences Longest common subsequence Longest palindromic substrings Longest increasing subsequence Words containing "the" substring Sum of the digits of n is substring of n Determine if a string is numeric Determine if a string is collapsible Determine if a string is squeezable Determine if a string has all unique characters Determine if a string has all the same characters Longest substrings without repeating characters Find words which contains all the vowels Find words which contains most consonants Find words which contains more than 3 vowels Find words which first and last three letters are equals Find words which odd letters are consonants and even letters are vowels or vice_versa Formatting Substring Rep-string Word wrap String case Align columns Literals/String Repeat a string Brace expansion Brace expansion using ranges Reverse a string Phrase reversals Comma quibbling Special characters String concatenation Substring/Top and tail Commatizing numbers Reverse words in a string Suffixation of decimal numbers Long literals, with continuations Numerical and alphabetical suffixes Abbreviations, easy Abbreviations, simple Abbreviations, automatic Song lyrics/poems/Mad Libs/phrases Mad Libs Magic 8-ball 99 Bottles of Beer The Name Game (a song) The Old lady swallowed a fly The Twelve Days of Christmas Tokenize Text between Tokenize a string Word break problem Tokenize a string with escaping Split a character string based on change of character Sequences Show ASCII table De Bruijn sequences Self-referential sequences Generate lower case ASCII alphabet

#Slate

Slate

[ | :s | s == s copy] applyTo: {'hello'}. "returns False"

http://rosettacode.org/wiki/Constrained_random_points_on_a_circle

Constrained random points on a circle

Task Generate 100 <x,y> coordinate pairs such that x and y are integers sampled from the uniform distribution with the condition that 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . Then display/plot them. The outcome should be a "fuzzy" circle. The actual number of points plotted may be less than 100, given that some pairs may be generated more than once. There are several possible approaches to accomplish this. Here are two possible algorithms. 1) Generate random pairs of integers and filter out those that don't satisfy this condition: 10 ≤ x 2 + y 2 ≤ 15 {\displaystyle 10\leq {\sqrt {x^{2}+y^{2}}}\leq 15} . 2) Precalculate the set of all possible points (there are 404 of them) and select randomly from this set.

#R

R

RMin <- 10 RMax <- 15 NPts <- 100 # instead of a for loop, we generate what should be enough points # also take care to have enough range to avoid rounding inaccuracies nBlock <- NPts * ((RMax/RMin) ^ 2) nValid <- 0 while (nValid < NPts) { X <- round(runif(nBlock, -RMax - 1, RMax + 1)) Y <- round(runif(nBlock, -RMax - 1, RMax + 1)) R <- sqrt(X^2 + Y^2) Valid <- ( (R >= RMin) & (R <= RMax) ) nValid <- sum(Valid) nBlock <- 2 * nBlock } plot(X[Valid][1:NPts],Y[Valid][1:NPts], pch=19, cex=0.25, col="blue", xlab="x",ylab="y",main="Fuzzy circle", xlim=c(-RMax,RMax), ylim=c(-RMax,RMax) )

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Rust

Rust

extern crate rand; use std::thread; use rand::thread_rng; use rand::distributions::{Range, IndependentSample}; fn main() { let mut rng = thread_rng(); let rng_range = Range::new(0u32, 100); for word in "Enjoy Rosetta Code".split_whitespace() { let snooze_time = rng_range.ind_sample(&mut rng); let local_word = word.to_owned(); std::thread::spawn(move || { thread::sleep_ms(snooze_time); println!("{}", local_word); }); } thread::sleep_ms(1000); }

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Scala

Scala

import scala.actors.Futures List("Enjoy", "Rosetta", "Code").map { x => Futures.future { Thread.sleep((Math.random * 1000).toInt) println(x) } }.foreach(_())

http://rosettacode.org/wiki/Concurrent_computing

Concurrent computing

Task Using either native language concurrency syntax or freely available libraries, write a program to display the strings "Enjoy" "Rosetta" "Code", one string per line, in random order. Concurrency syntax must use threads, tasks, co-routines, or whatever concurrency is called in your language.

#Scheme

Scheme

(parallel-execute (lambda () (print "Enjoy")) (lambda () (print "Rosetta")) (lambda () (print "Code")))

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#XLISP

XLISP

(defmacro f10-at-compile-time () (* 2 3 4 5 6 7 8 9 10))

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#XPL0

XPL0

code IntOut=11; IntOut(0, 10*9*8*7*6*5*4*3*2);

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#zkl

zkl

const { [1..10].reduce('*).println(" parse time") } #fcn fact(N) { [1..N].reduce('*).println(" tokenize time"); ""} // paste output of fact into source #tokenize fact(10) println("compiled program running.");

http://rosettacode.org/wiki/Compile-time_calculation

Compile-time calculation

Some programming languages allow calculation of values at compile time. Task Calculate 10! (ten factorial) at compile time. Print the result when the program is run. Discuss what limitations apply to compile-time calculations in your language.

#Zig

Zig

http://rosettacode.org/wiki/Conditional_structures

Conditional structures

Control Structures These are examples of control structures. You may also be interested in: Conditional structures Exceptions Flow-control structures Loops Task List the conditional structures offered by a programming language. See Wikipedia: conditionals for descriptions. Common conditional structures include if-then-else and switch. Less common are arithmetic if, ternary operator and Hash-based conditionals. Arithmetic if allows tight control over computed gotos, which optimizers have a hard time to figure out.

#Aime

Aime

if (c1) { // first condition is true... } elif (c2) { // second condition is true... } elif (c3) { // third condition is true... } else { // none was true... }