Merge pull request #177 from jlp765/master

More Rosetta examples

src/rosetta/next_highest_int_from_digits.flx

@@ -0,0 +1,70 @@
+fun digits (n: int) = {
+  // Return the list of digits of "n" in reverse order.
+  var res = darray[int]();
+  if n == 0 do 
+    res += 0; 
+    return res; 
+  done;
+  while n != 0 do
+    res += (n % 10);
+    n = n / 10;
+  done
+  return res;
+}
+
+proc sort_a_slice_desc (var d, n) = {
+  val nlen = n - 1;
+  var d2 = darray[int](d.(0..nlen));    // a copy of a slice of d
+  sort d2;                              // sorted Asc
+  for var i in nlen downto 0 do         // saved as desc
+    set(d, nlen - i, get(d2,i));
+  done
+}
+
+fun next_highest (n: int) = {
+  // Find the next highest integer of "n".
+  // If none is found, "n" is returned.
+  var d = digits(n);    // digits are in reverse order.
+  var m = d.0;
+  var delta = 0;
+  var best = 0;
+  var diff = 0;
+  var i = 0;
+  var j = 0;
+  var k = 0;
+  var di = 0;
+  iloop: for i in 0 upto (d.len.int - 1) do
+    di = d.i.int;
+    if di < m do
+      // Find the digit greater then d.(i) and closest to it.
+      delta = (m - di + 1);
+      best = 0;
+      for j in 0 upto (i - 1) do
+        diff = d.j.int - di;
+        if diff > 0 and diff < delta do
+          // Greater and closest.
+          delta = diff;
+          best = j;
+        done
+      done
+      // Exchange digits.
+      set(d,i, get(d,best));
+      set(d,best,di);
+      // Sort previous digits.
+      sort_a_slice_desc(d, i);  // d.(0..<i)
+      break iloop;
+    else 
+      m = di;
+    done
+  done
+  // Compute the value from the digits (in reverse order).
+  var result = 0;
+  for k in (d.len.int - 1) downto 0 do
+    //println$ d.(k);
+    result = (10 * result) + d.k.int; 
+  done
+  return result;
+}
+
+for n in list (0, 9, 12, 21, 12453, 738440, 45072010, 95322020) perform
+  println$ n.str + " -> " + str(next_highest(n));

src/rosetta/ordered_words.flx

@@ -0,0 +1,44 @@
+val dict_file = "unixdict.txt";
+
+fun is_sorted(var s: string): bool = {
+  var last = char("A");
+  for c in s do
+    if c < last return false;
+    last = c;
+  done
+  return true;
+}
+
+fun join (a: darray[string], delim:string): string = {
+  var sres = "";
+  var alimit = a.len.int - 1;
+  for var i in 0 upto alimit do
+    if i == alimit do
+      sres += a.i;
+      return sres;
+    done
+    sres += (a.i + delim);
+  done
+  return sres;
+}
+
+var mx = 0;
+var word = "";
+var words = darray[string]();
+var wlen = 0;
+
+var f = fopen_input_text dict_file;
+if valid f do 
+  while not (feof f) do
+    word = (readln f).rstrip;  // trailing CR/LF isn't ordered
+    wlen = word.len.int;
+    if (wlen >= mx) and is_sorted(word) do
+      if wlen > mx perform 
+        mx, words = wlen, darray[string](); 
+      words += word;
+    done
+  done
+  fclose f;
+done
+
+println$ join$ words, ", ";

src/rosetta/palindrome_detection.flx

@@ -0,0 +1,30 @@
+val Exact = true;
+val Inexact = false;
+
+fun is_palindrome (p): bool = {
+  // Return true if the string is a palindrome.
+  var plen = p.len.int;
+  for var i in 1 upto (plen >> 1) do
+    if p.(i - 1) != p.(plen - i) 
+      return false;
+  done
+  return true;
+}
+
+fun is_palindrome(s, exact: bool): string = {
+  // Return true if a string is a palindrome.
+  // If not exact, ignore white spaces and ignore case.
+  var res = "";
+  if exact do
+    res = "'" + s + "' an exact palindrome? ";
+    return res + str(is_palindrome s);
+  else
+    res = "'" + s + "' an inexact palindrome? ";
+    return res + str(is_palindrome$ tolower(s));
+  done
+}
+
+println$ is_palindrome$ "racecar", Exact;
+println$ is_palindrome$ "Hannah", Exact;
+println$ is_palindrome$ "Hannah", Inexact;
+println$ is_palindrome$ "This is a Palindrome", Inexact;

src/rosetta/prime_triangle.flx

@@ -0,0 +1,92 @@
+
+fun is_prime (lval: int) : bool = {
+  assert lval >= 0 and lval < 64;
+  var prime_lst = (0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0,
+                   0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,
+                   0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1,
+                   0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0);
+  if prime_lst.lval == 1 return true;
+  return false;
+}
+
+fun prime_triangle_row (var a: varray[int], var start, var alen) : bool = {
+  if (start + 2 >= alen)
+    return is_prime(a.start + a.(start + 1));
+  var i = start + 1;
+  var j = 0;
+  while (i + 1) < alen do
+    if is_prime(a.start + a.i) do
+      // swap
+      j = a.i;
+      set(a,i, get(a,start + 1));
+      set(a,start + 1,j);
+      if prime_triangle_row$ (a, start + 1, alen) 
+        return true;
+      // swap back
+      j = a.i;
+      set(a,i, get(a,start + 1));
+      set(a,start + 1,j);
+    done
+    i += 2;
+  done
+  return false;
+}
+
+fun prime_triangle_count (var a: varray[int], var start, var alen) : int = {
+  var count = 0;
+  if (start + 2 >= alen)
+    if is_prime(a.start + a.(start + 1))
+      return (count + 1);
+  var i = start + 1;
+  var j = 0;
+  while (i + 1) < alen do
+    if is_prime(a.start + a.i) do
+      // swap
+      j = a.i;
+      set(a,i, get(a,start + 1));
+      set(a,start + 1,j);
+      count += prime_triangle_count$ (a, start + 1, alen);
+      // swap back
+      j = a.i;
+      set(a,i, get(a,start + 1));
+      set(a,start + 1,j);
+    done
+    i += 2;
+  done
+  return count;
+}
+
+proc print_arr (a: varray[int], start: int, n: int) = {
+  if n == 0 return;
+  print$ f"%2i" (a.(start));
+  for var i in start + 1 upto (start + n - 1) perform
+      print$ f" %2i" (a.i);
+  println$ "";
+}
+
+proc main () = {
+  var a = varray[int] 22.size;
+  var n = 0;
+  var i = 0;
+  for n in 2 upto 20 do
+    for i in 0 upto (n - 1) do
+      a += (i + 1);
+    done
+    if prime_triangle_row(a,0,n) do 
+      print_arr(a,0,n);
+    done
+    erase(a,0,n);
+  done
+  println$ "";
+  for n in 2 upto 20 do
+    for i in 0 upto (n - 1) do
+      a += (i + 1);
+    done
+    if n > 2 do print$ " "; done
+    print$ f"%d" (prime_triangle_count(a,0,n)); 
+    erase(a,0,n);
+  done
+  println$ "";
+}
+
+main;

src/rosetta/rename_a_file.flx

@@ -0,0 +1,20 @@
+//
+// Unix based OS
+//
+// if file of directory is missing, 
+// then throws an error like:
+//
+// mv: cannot stat 'input.txt': No such file or directory 
+//
+
+open Shell;
+
+proc cmd (s) = {
+  var x = system(s);
+  x += 0;  // trigger the call
+}
+
+cmd$ "mv input.txt output.txt";
+cmd$ "mv /input.txt /output.txt";
+cmd$ "mv docs mydocs";
+cmd$ "mv /docs /mydocs";

src/rosetta/repeat.flx

@@ -0,0 +1,6 @@
+proc example () => println$ "Example";
+
+proc repeat_proc (f, n) =>
+  for var i in 0 upto (n - 1) perform f;
+
+repeat_proc$ example, 3;

src/rosetta/repeat_a_string.flx

@@ -0,0 +1,8 @@
+fun srepeat (s,n): string = {
+  var sres = "";
+  for var i in 1 upto n perform
+    sres += s;
+  return sres;
+}
+
+println$ srepeat$ "Ha", 3;  // output: HaHaHa

src/rosetta/return_multiple_values.flx

@@ -0,0 +1,10 @@
+fun addsub(x, y) =>
+  x + y, x - y;
+
+var sum = 0;
+var diff = 0;
+
+sum, diff = addsub(33, 12);
+
+println$ "33 + 12 = " + sum.str;
+println$ "33 - 12 = " + diff.str;