Solutions for challenge #144

16 files changed, 774 insertions, 0 deletions

diff --git a/challenge-144/roger-bell-west/kotlin/ch-1.kt b/challenge-144/roger-bell-west/kotlin/ch-1.kt
new file mode 100644
index 0000000000..507b113ba5
--- /dev/null
+++ b/challenge-144/roger-bell-west/kotlin/ch-1.kt
@@ -0,0 +1,43 @@
+fun semiprime(mx: Int): ArrayList<Int> {
+    val mxx: Int=mx/2
+    var primesh=mutableSetOf<Int>()
+    for (i in 2..mxx) {
+        primesh.add(i)
+    }
+    var p: Int=2
+    while (p*p <= mxx) {
+        if (primesh.contains(p)) {
+            for (i in p*p..mxx step p) {
+                primesh.remove(i)
+            }
+        }
+        if (p==2) {
+            p -= 1
+        }
+        p += 2
+    }
+    var primes=ArrayList(primesh.distinct())
+    primes.sort()
+    var semiprimesh=mutableSetOf<Int>()
+    for (i in 0..primes.size-1) {
+        for (j in i..primes.size-1) {
+            val t=primes[i]*primes[j]
+            if (t < mx) {
+                semiprimesh.add(t)
+            } else {
+                break
+            }
+        }
+    }
+    var semiprimes=ArrayList(semiprimesh.distinct())
+    semiprimes.sort()
+    return semiprimes
+}
+
+fun main() {
+  if (semiprime(100) == listOf(4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95)) {
+    println("Pass")
+  } else {
+    println("FAIL")
+  }
+}
diff --git a/challenge-144/roger-bell-west/kotlin/ch-2.kt b/challenge-144/roger-bell-west/kotlin/ch-2.kt
new file mode 100644
index 0000000000..fc93ea4a7e
--- /dev/null
+++ b/challenge-144/roger-bell-west/kotlin/ch-2.kt
@@ -0,0 +1,42 @@
+fun ulam(u: Int, v: Int, ccount: Int): ArrayList<Int> {
+    var ulams=arrayListOf<Int>(u,v)
+    var sieve=ArrayList<Int>()
+    var uc=v
+    while (ulams.size < ccount) {
+        for (i in sieve.size..uc+ulams[ulams.size-2]) {
+            sieve.add(0)
+        }
+        for (i in 0..ulams.size-2) {
+            sieve[uc + ulams[i] - 1] += 1
+        }
+        for (i in uc..sieve.size-1) {
+            if (sieve[i] == 1) {
+                uc=i+1
+                ulams.add(uc)
+                break
+            }
+        }
+    }
+    return ulams
+}
+
+fun main() {
+  if (ulam(1,2,10) == listOf(1, 2, 3, 4,  6 , 8, 11, 13, 16, 18)) {
+    print("Pass")
+  } else {
+    print("FAIL")
+  }
+  print(" ")
+  if (ulam(2,3,10) == listOf(2, 3, 5, 7,  8,  9, 13, 14, 18, 19)) {
+    print("Pass")
+  } else {
+    print("FAIL")
+  }
+  print(" ")
+  if (ulam(2,5,10) == listOf(2, 5, 7, 9, 11, 12, 13, 15, 19, 23)) {
+    print("Pass")
+  } else {
+    print("FAIL")
+  }
+  println("")
+}
diff --git a/challenge-144/roger-bell-west/lua/ch-1.lua b/challenge-144/roger-bell-west/lua/ch-1.lua
new file mode 100755
index 0000000000..bdb74a1e02
--- /dev/null
+++ b/challenge-144/roger-bell-west/lua/ch-1.lua
@@ -0,0 +1,77 @@
+#! /usr/bin/lua
+
+-- by Michael Anderson at
+-- https://stackoverflow.com/questions/8722620/comparing-two-index-tables-by-index-value-in-lua
+function recursive_compare(t1,t2)
+  -- Use usual comparison first.
+  if t1==t2 then return true end
+  -- We only support non-default behavior for tables
+  if (type(t1)~="table") then return false end
+  -- They better have the same metatables
+  local mt1 = getmetatable(t1)
+  local mt2 = getmetatable(t2)
+  if( not recursive_compare(mt1,mt2) ) then return false end
+
+  -- Check each key-value pair
+  -- We have to do this both ways in case we miss some.
+  -- TODO: Could probably be smarter and not check those we've 
+  -- already checked though!
+  for k1,v1 in pairs(t1) do
+    local v2 = t2[k1]
+    if( not recursive_compare(v1,v2) ) then return false end
+  end
+  for k2,v2 in pairs(t2) do
+    local v1 = t1[k2]
+    if( not recursive_compare(v1,v2) ) then return false end
+  end
+
+  return true  
+end
+
+function semiprime(mx)
+  mxx = math.tointeger(mx/2)
+  primesh = {}
+  for i = 2, mxx do
+    primesh[i] = true
+  end
+  p = 2
+  while p * p <= mxx do
+    if primesh[p] ~= nil then
+      for i = p*p,mxx,p do
+        primesh[i] = nil
+      end
+    end
+    if p == 2 then
+      p = p - 1
+    end
+    p = p + 2
+  end
+  primes = {}
+  for k,v in pairs(primesh) do
+    table.insert(primes,k)
+  end
+  semiprimesh = {}
+  for i = 1,#primes-1 do
+    for j = i,#primes do
+      t = primes[i]*primes[j]
+      if t < mx then
+        semiprimesh[t]=true
+      else
+       break
+      end
+    end
+  end
+  semiprimes = {}
+  for k,v in pairs(semiprimesh) do
+    table.insert(semiprimes,k)
+  end
+  table.sort(semiprimes)
+  return semiprimes
+end
+
+if recursive_compare(semiprime(100),{4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95}) then
+  io.write("Pass")
+else
+  io.write("FAIL")
+end
+print("")
\ No newline at end of file
diff --git a/challenge-144/roger-bell-west/lua/ch-2.lua b/challenge-144/roger-bell-west/lua/ch-2.lua
new file mode 100755
index 0000000000..efda3fdf26
--- /dev/null
+++ b/challenge-144/roger-bell-west/lua/ch-2.lua
@@ -0,0 +1,74 @@
+#! /usr/bin/lua
+
+-- by Michael Anderson at
+-- https://stackoverflow.com/questions/8722620/comparing-two-index-tables-by-index-value-in-lua
+function recursive_compare(t1,t2)
+  -- Use usual comparison first.
+  if t1==t2 then return true end
+  -- We only support non-default behavior for tables
+  if (type(t1)~="table") then return false end
+  -- They better have the same metatables
+  local mt1 = getmetatable(t1)
+  local mt2 = getmetatable(t2)
+  if( not recursive_compare(mt1,mt2) ) then return false end
+
+  -- Check each key-value pair
+  -- We have to do this both ways in case we miss some.
+  -- TODO: Could probably be smarter and not check those we've 
+  -- already checked though!
+  for k1,v1 in pairs(t1) do
+    local v2 = t2[k1]
+    if( not recursive_compare(v1,v2) ) then return false end
+  end
+  for k2,v2 in pairs(t2) do
+    local v1 = t1[k2]
+    if( not recursive_compare(v1,v2) ) then return false end
+  end
+
+  return true  
+end
+
+function ulam(u,v,count)
+  ulams={u,v}
+  sieve={}
+  uc=v
+  while #ulams < count do
+    for i = #sieve+1,uc + ulams[#ulams-1] do
+      table.insert(sieve,0)
+    end
+    for i = 1,#ulams-1 do
+      j=uc+ulams[i]
+      sieve[j] = sieve[j] + 1
+    end
+    for i = uc+1,#sieve do
+      if sieve[i] == 1 then
+        uc = i
+        table.insert(ulams,uc)
+        break
+      end
+    end
+  end
+  return ulams
+end
+
+if recursive_compare(ulam(1,2,10),{1, 2, 3, 4, 6, 8, 11, 13, 16, 18}) then
+  io.write("Pass")
+else
+  io.write("FAIL")
+end
+io.write(" ")
+
+if recursive_compare(ulam(2,3,10),{2, 3, 5, 7, 8, 9, 13, 14, 18, 19}) then
+  io.write("Pass")
+else
+  io.write("FAIL")
+end
+io.write(" ")
+
+if recursive_compare(ulam(2,5,10),{2, 5, 7, 9, 11, 12, 13, 15, 19, 23}) then
+  io.write("Pass")
+else
+  io.write("FAIL")
+end
+
+print("")
\ No newline at end of file
diff --git a/challenge-144/roger-bell-west/perl/ch-1.pl b/challenge-144/roger-bell-west/perl/ch-1.pl
new file mode 100755
index 0000000000..ed9ff0ba3d
--- /dev/null
+++ b/challenge-144/roger-bell-west/perl/ch-1.pl
@@ -0,0 +1,44 @@
+#! /usr/bin/perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 1;
+
+is_deeply(semiprime(100),[4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95],'example 1');
+
+sub semiprime {
+  my $mx=shift;
+  my $mxx=int($mx/2);
+  my @primes;
+  {
+    my %primesh=map {$_ => 1} (2..$mxx);
+    my $p=2;
+    while ($p*$p <= $mxx) {
+      if ($primesh{$p}) {
+        my $i=$p*$p;
+        while ($i <= $mxx) {
+          delete $primesh{$i};
+          $i += $p;
+        }
+      }
+      if ($p==2) {
+        $p--;
+      }
+      $p+=2;
+    }
+    @primes=sort {$a <=> $b} keys %primesh;
+  }
+  my %semiprimesh;
+  foreach my $i (0..$#primes) {
+    foreach my $j ($i..$#primes) {
+      my $t=$primes[$i]*$primes[$j];
+      if ($t <= $mx) {
+        $semiprimesh{$t}=1;
+      } else {
+        next;
+      }
+    }
+  }
+  return [sort {$a <=> $b} keys %semiprimesh];
+}
diff --git a/challenge-144/roger-bell-west/perl/ch-2.pl b/challenge-144/roger-bell-west/perl/ch-2.pl
new file mode 100755
index 0000000000..7f9a8d2de3
--- /dev/null
+++ b/challenge-144/roger-bell-west/perl/ch-2.pl
@@ -0,0 +1,32 @@
+#! /usr/bin/perl
+
+use strict;
+use warnings;
+
+use Test::More tests => 3;
+
+is_deeply(ulam(1,2,10),[1, 2, 3, 4,  6 , 8, 11, 13, 16, 18],'example 1');
+is_deeply(ulam(2,3,10),[2, 3, 5, 7,  8,  9, 13, 14, 18, 19],'example 2');
+is_deeply(ulam(2,5,10),[2, 5, 7, 9, 11, 12, 13, 15, 19, 23],'example 3');
+
+sub ulam {
+  my ($u,$v,$count)=@_;
+  my @ulams=($u,$v);
+  my @sieve;
+  my $uc=$v;
+  while (scalar @ulams < $count) {
+    my $ss=$uc+$ulams[-2];
+    push @sieve,(0) x ($ss-scalar @sieve);
+    foreach my $i (0..$#ulams-1) {
+      $sieve[$uc + $ulams[$i] - 1]++;
+    }
+    foreach my $i ($uc..$#sieve) {
+      if ($sieve[$i]==1) {
+        $uc=$i+1;
+        push @ulams,$uc;
+        last;
+      }
+    }
+  }
+  return \@ulams;
+}
diff --git a/challenge-144/roger-bell-west/postscript/ch-1.ps b/challenge-144/roger-bell-west/postscript/ch-1.ps
new file mode 100644
index 0000000000..4c14a618b4
--- /dev/null
+++ b/challenge-144/roger-bell-west/postscript/ch-1.ps
@@ -0,0 +1,95 @@
+%!PS
+
+/bubblesort {
+    mark exch aload pop counttomark /idx
+    exch store
+    {
+        0 1 idx 1 sub {
+            pop 2 copy gt {
+                exch
+            } if idx 1 roll
+        } for
+        idx 1 roll /idx idx 1 sub store
+        idx 0 eq {
+            exit
+        } if
+    } loop
+]
+} store
+
+/aeq {
+    2 dict begin
+    /a exch def
+    /b exch def
+    a length b length eq {
+        /e true def
+        0 1 a length 1 sub {
+            dup a exch get
+            exch b exch get ne {
+                /e false def
+                exit
+            } if
+        } for
+        e
+    } {
+        false
+    } ifelse
+    end
+} bind def
+
+/apush { % [a b] c -> [a b c]
+    /t exch def
+    [ exch aload pop t ]
+} bind def
+
+/semiprime {
+    /mx exch def
+    /mxx mx 2 idiv def
+    /primesh mxx dict def
+    2 1 mxx {
+        primesh exch 1 put
+    } for
+    /p 2 def
+    {
+        p dup mul mxx le not {
+            exit
+        } if
+        primesh p known {
+            p dup mul p mxx {
+              primesh exch undef
+            } for
+        } if
+        p 2 eq {
+            /p p 1 sub def
+        } if
+        /p p 2 add def
+    } loop
+    /primes 0 array def
+    primesh {
+        pop
+        /primes exch primes exch apush def
+    } forall
+    /primes primes bubblesort def
+    /semiprimesh mx dict def
+    0 1 primes length 1 sub {
+        /i exch def
+        i 1 primes length 1 sub {
+            primes exch get primes i get mul /t exch def
+            t mx le {
+                semiprimesh t 1 put
+            } {
+                exit
+            } ifelse 
+        } for
+    } for
+    /semiprimes 0 array def
+    semiprimesh {
+        pop
+        /semiprimes exch semiprimes exch apush def
+    } forall
+    /semiprimes semiprimes bubblesort def
+    semiprimes
+} bind def
+
+100 semiprime [ 4 6 9 10 14 15 21 22 25 26 33 34 35 38 39 46 49 51 55 57 58 62 65 69 74 77 82 85 86 87 91 93 94 95 ]
+aeq { (Pass) } { (FAIL) } ifelse =
diff --git a/challenge-144/roger-bell-west/postscript/ch-2.ps b/challenge-144/roger-bell-west/postscript/ch-2.ps
new file mode 100644
index 0000000000..cc962342c0
--- /dev/null
+++ b/challenge-144/roger-bell-west/postscript/ch-2.ps
@@ -0,0 +1,63 @@
+%!PS
+
+/aeq {
+    2 dict begin
+    /a exch def
+    /b exch def
+    a length b length eq {
+        /e true def
+        0 1 a length 1 sub {
+            dup a exch get
+            exch b exch get ne {
+                /e false def
+                exit
+            } if
+        } for
+        e
+    } {
+        false
+    } ifelse
+    end
+} bind def
+
+/apush { % [a b] c -> [a b c]
+    /t exch def
+    [ exch aload pop t ]
+} bind def
+
+/ulam {
+    /ccount exch def
+    /v exch def
+    /u exch def
+    /ulams [ u v ] def
+    /sieve 0 array def
+    /uc v def
+    {
+        ulams length ccount ge {
+            exit
+        } if
+        uc ulams ulams length 2 sub get add sieve length sub {
+            /sieve sieve 0 apush def
+        } repeat
+        0 1 ulams length 2 sub {
+            ulams exch get uc add 1 sub /t exch def
+            sieve t sieve t get 1 add put
+        } for
+        uc 1 sieve length 1 sub {
+            /i exch def
+            sieve i get 1 eq {
+                /uc i 1 add def
+                /ulams ulams uc apush def
+                exit
+            } if
+        } for
+    } loop
+    ulams
+} bind def
+
+1 2 10 ulam [ 1 2 3 4  6  8 11 13 16 18 ]
+aeq { (Pass) } { (FAIL) } ifelse print ( ) print
+2 3 10 ulam [ 2 3 5 7  8  9 13 14 18 19 ]
+aeq { (Pass) } { (FAIL) } ifelse print ( ) print
+2 5 10 ulam [ 2 5 7 9 11 12 13 15 19 23 ]
+aeq { (Pass) } { (FAIL) } ifelse =
diff --git a/challenge-144/roger-bell-west/python/ch-1.py b/challenge-144/roger-bell-west/python/ch-1.py
new file mode 100755
index 0000000000..34a6e6d424
--- /dev/null
+++ b/challenge-144/roger-bell-west/python/ch-1.py
@@ -0,0 +1,35 @@
+#! /usr/bin/python3
+
+import unittest
+
+def semiprime(mx):
+  mxx=int(mx/2)
+  primesh=set(range(2,mxx+1))
+  p=2
+  while p*p <= mxx:
+    if p in primesh:
+      for i in range(p*p,mx+1,p):
+        primesh.discard(i)
+    if p==2:
+      p -= 1
+    p += 2
+  primes=list(primesh)
+  primes.sort()
+  semiprimesh=set()
+  for i in range(len(primes)):
+    for j in range(i,len(primes)):
+      t=primes[i]*primes[j]
+      if t <= mx:
+        semiprimesh.add(t)
+      else:
+        break
+  semiprimes=list(semiprimesh)
+  semiprimes.sort()
+  return semiprimes
+
+class TestSemiprime(unittest.TestCase):
+
+        def test_ex1(self):
+          self.assertEqual(semiprime(100),[4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95],'example 1')
+
+unittest.main()
diff --git a/challenge-144/roger-bell-west/python/ch-2.py b/challenge-144/roger-bell-west/python/ch-2.py
new file mode 100755
index 0000000000..b569b0f8cf
--- /dev/null
+++ b/challenge-144/roger-bell-west/python/ch-2.py
@@ -0,0 +1,31 @@
+#! /usr/bin/python3
+
+import unittest
+
+def ulam(u,v,count):
+  ulams=[u,v]
+  sieve=[]
+  uc=v
+  while len(ulams) < count:
+    sieve.extend([0] * (uc+ulams[-2]-len(sieve)))
+    for i in range(len(ulams)-1):
+      sieve[uc + ulams[i] - 1] += 1
+    for i in range(uc,len(sieve)):
+      if sieve[i]==1:
+        uc=i+1
+        ulams.append(uc)
+        break
+  return ulams
+
+class TestUlam(unittest.TestCase):
+
+        def test_ex1(self):
+          self.assertEqual(ulam(1,2,10),[1, 2, 3, 4,  6 , 8, 11, 13, 16, 18],'example 1')
+
+        def test_ex2(self):
+          self.assertEqual(ulam(2,3,10),[2, 3, 5, 7,  8,  9, 13, 14, 18, 19],'example 2')
+
+        def test_ex3(self):
+          self.assertEqual(ulam(2,5,10),[2, 5, 7, 9, 11, 12, 13, 15, 19, 23],'example 3')
+
+unittest.main()
diff --git a/challenge-144/roger-bell-west/raku/ch-1.p6 b/challenge-144/roger-bell-west/raku/ch-1.p6
new file mode 100755
index 0000000000..62b4f98280
--- /dev/null
+++ b/challenge-144/roger-bell-west/raku/ch-1.p6
@@ -0,0 +1,41 @@
+#! /usr/bin/perl6
+
+use Test;
+plan 1;
+
+is-deeply(semiprime(100),(4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95),'example 1');
+
+sub semiprime($mx) {
+  my @primes;
+  {
+    my $mxx=floor($mx/2);
+    my $primesh=(2..$mxx).SetHash;
+    my $p=2;
+    while ($p*$p <= $mxx) {
+      if ($primesh{$p}:exists) {
+        my $i=$p*$p;
+        while ($i <= $mxx) {
+          $primesh{$i}:delete;
+          $i += $p;
+        }
+      }
+      if ($p==2) {
+        $p--;
+      }
+      $p+=2;
+    }
+    @primes=$primesh.keys.sort;
+  }
+  my $semiprimesh=SetHash();
+  for 0..@primes.end -> $i {
+    for $i..@primes.end -> $j {
+      my $t=@primes[$i]*@primes[$j];
+      if ($t <= $mx) {
+        $semiprimesh{$t}++;
+      } else {
+        next;
+      }
+    }
+  }
+  return $semiprimesh.keys.map({$_+0}).sort;
+}
diff --git a/challenge-144/roger-bell-west/raku/ch-2.p6 b/challenge-144/roger-bell-west/raku/ch-2.p6
new file mode 100755
index 0000000000..4dace477d0
--- /dev/null
+++ b/challenge-144/roger-bell-west/raku/ch-2.p6
@@ -0,0 +1,29 @@
+#! /usr/bin/perl6
+
+use Test;
+plan 3;
+
+is-deeply(ulam(1,2,10),[1, 2, 3, 4,  6 , 8, 11, 13, 16, 18],'example 1');
+is-deeply(ulam(2,3,10),[2, 3, 5, 7,  8,  9, 13, 14, 18, 19],'example 2');
+is-deeply(ulam(2,5,10),[2, 5, 7, 9, 11, 12, 13, 15, 19, 23],'example 3');
+
+sub ulam($u,$v,$count) {
+  my @ulams=[$u,$v];
+  my @sieve;
+  my $uc=$v;
+  while (@ulams.elems < $count) {
+    my $ss=$uc+@ulams[*-2];
+    @sieve.append(0 xx ($ss-@sieve.elems));
+    for (0..@ulams.end-1) -> $i {
+      @sieve[$uc + @ulams[$i] - 1]++;
+    }
+    for ($uc..@sieve.end) -> $i {
+      if (@sieve[$i]==1) {
+        $uc=$i+1;
+        push @ulams,$uc;
+        last;
+      }
+    }
+  }
+  return @ulams;
+}
diff --git a/challenge-144/roger-bell-west/ruby/ch-1.rb b/challenge-144/roger-bell-west/ruby/ch-1.rb
new file mode 100755
index 0000000000..77d5650ccd
--- /dev/null
+++ b/challenge-144/roger-bell-west/ruby/ch-1.rb
@@ -0,0 +1,43 @@
+#! /usr/bin/ruby
+
+require 'set'
+
+def semiprime(mx)
+  mxx=(mx/2).to_i
+  primesh=Set.new(2..mxx)
+  p=2
+  while p*p <= mxx do
+    if primesh.include?(p)
+      (p*p..mxx).step(p) do |i|
+        primesh.delete?(i)
+      end
+    end
+    if p==2 then
+      p -= 1
+    end
+    p += 2
+  end
+  primes=primesh.each.sort
+  semiprimesh=Set.new
+  0.upto(primes.length()-1) do |i|
+    i.upto(primes.length()-1) do |j|
+      t=primes[i]*primes[j]
+      if t <= mx then
+        semiprimesh.add(t)
+      else
+        break
+      end
+    end
+  end
+  return semiprimesh.each.sort
+end
+
+require 'test/unit'
+
+class TestSemiprime < Test::Unit::TestCase
+
+  def test_ex1
+    assert_equal([4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49, 51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95],semiprime(100))
+  end
+
+end
diff --git a/challenge-144/roger-bell-west/ruby/ch-2.rb b/challenge-144/roger-bell-west/ruby/ch-2.rb
new file mode 100755
index 0000000000..9ec1e9a7d9
--- /dev/null
+++ b/challenge-144/roger-bell-west/ruby/ch-2.rb
@@ -0,0 +1,39 @@
+#! /usr/bin/ruby
+
+def ulam(u,v,count)
+  ulams=[u,v]
+  sieve=[]
+  uc=v
+  while ulams.length() < count do
+    sieve.concat(Array.new(uc+ulams[-2]-sieve.length,0))
+    0.upto(ulams.length-2) do |i|
+      sieve[uc + ulams[i] - 1] += 1
+    end
+    uc.upto(sieve.length-1) do |i|
+      if sieve[i]==1 then
+        uc=i+1
+        ulams.push(uc)
+        break
+      end
+    end
+  end
+  return ulams
+end
+
+require 'test/unit'
+
+class TestUlam < Test::Unit::TestCase
+
+  def test_ex1
+    assert_equal([1, 2, 3, 4,  6 , 8, 11, 13, 16, 18],ulam(1,2,10))
+  end
+
+  def test_ex2
+    assert_equal([2, 3, 5, 7,  8,  9, 13, 14, 18, 19],ulam(2,3,10))
+  end
+
+  def test_ex3
+    assert_equal([2, 5, 7, 9, 11, 12, 13, 15, 19, 23],ulam(2,5,10))
+  end
+
+end
diff --git a/challenge-144/roger-bell-west/rust/ch-1.rs b/challenge-144/roger-bell-west/rust/ch-1.rs
new file mode 100755
index 0000000000..d34828e30b
--- /dev/null
+++ b/challenge-144/roger-bell-west/rust/ch-1.rs
@@ -0,0 +1,49 @@
+#! /bin/sh
+//usr/bin/env rustc --test $0 -o ${0}x && ./${0}x; rm -f ${0}x ; exit
+
+use std::collections::HashSet;
+use std::iter::FromIterator;
+
+#[test]
+fn test_ex1() {
+    assert_eq!(
+        semiprime(100),
+        vec![
+            4, 6, 9, 10, 14, 15, 21, 22, 25, 26, 33, 34, 35, 38, 39, 46, 49,
+            51, 55, 57, 58, 62, 65, 69, 74, 77, 82, 85, 86, 87, 91, 93, 94, 95
+        ]
+    );
+}
+
+fn semiprime(mx: u32) -> Vec<u32> {
+    let mxx = mx / 2;
+    let mut primesh: HashSet<u32> = HashSet::from_iter(2..=mxx);
+    let mut p = 2;
+    while p * p <= mxx {
+        if primesh.contains(&p) {
+            for i in (p * p..=mxx).step_by(p as usize) {
+                primesh.remove(&i);
+            }
+        }
+        if p == 2 {
+            p -= 1;
+        }
+        p += 2;
+    }
+    let mut primes = primesh.iter().map(|i| *i).collect::<Vec<u32>>();
+    primes.sort();
+    let mut semiprimesh: HashSet<u32> = HashSet::new();
+    for i in 0..primes.len() {
+        for j in i..primes.len() {
+            let t = primes[i] * primes[j];
+            if t < mx {
+                semiprimesh.insert(t);
+            } else {
+                break;
+            }
+        }
+    }
+    let mut semiprimes = semiprimesh.iter().map(|i| *i).collect::<Vec<u32>>();
+    semiprimes.sort();
+    semiprimes
+}
diff --git a/challenge-144/roger-bell-west/rust/ch-2.rs b/challenge-144/roger-bell-west/rust/ch-2.rs
new file mode 100755
index 0000000000..609a177407
--- /dev/null
+++ b/challenge-144/roger-bell-west/rust/ch-2.rs
@@ -0,0 +1,37 @@
+#! /bin/sh
+//usr/bin/env rustc --test $0 -o ${0}x && ./${0}x; rm -f ${0}x ; exit
+
+#[test]
+fn test_ex1() {
+    assert_eq!(ulam(1, 2, 10), vec![1, 2, 3, 4, 6, 8, 11, 13, 16, 18]);
+}
+
+#[test]
+fn test_ex2() {
+    assert_eq!(ulam(2, 3, 10), vec![2, 3, 5, 7, 8, 9, 13, 14, 18, 19]);
+}
+
+#[test]
+fn test_ex3() {
+    assert_eq!(ulam(2, 5, 10), vec![2, 5, 7, 9, 11, 12, 13, 15, 19, 23]);
+}
+
+fn ulam(u: usize, v: usize, count: usize) -> Vec<usize> {
+    let mut ulams = Vec::from([u, v]);
+    let mut sieve = vec![];
+    let mut uc = v;
+    while ulams.len() < count {
+        sieve.extend(vec![0; uc + ulams[ulams.len() - 2] - sieve.len()]);
+        for i in 0..=ulams.len() - 2 {
+            sieve[uc + ulams[i] - 1] += 1;
+        }
+        for i in uc..sieve.len() {
+            if sieve[i] == 1 {
+                uc = i + 1;
+                ulams.push(uc);
+                break;
+            }
+        }
+    }
+    ulams
+}