Solutions for challenge #174

challenge-174/roger-bell-west/javascript/ch-1.js

@@ -0,0 +1,77 @@
+#! /usr/bin/node
+
+"use strict"
+
+function deepEqual(a,b)
+{
+    if( (typeof a == 'object' && a != null) &&
+        (typeof b == 'object' && b != null) )
+    {
+        var count = [0,0]
+        for( var key in a) count[0]++
+        for( var key in b) count[1]++
+        if( count[0]-count[1] != 0) {return false}
+        for( var key in a)
+        {
+            if(!(key in b) || !deepEqual(a[key],b[key])) {return false}
+        }
+        for( var key in b)
+        {
+            if(!(key in a) || !deepEqual(b[key],a[key])) {return false}
+        }
+        return true
+    }
+    else
+    {
+        return a === b
+    }
+}
+
+function disarium(ct) {
+    let o = [];
+    let pows = [new Array(10).fill(1)];
+    let c = 0;
+    while (true) {
+        let disar = 0;
+        if (c > 0) {
+            let ca = c;
+            let cl = [];
+            let tx = 0;
+            while (ca > 0) {
+                tx++;
+                cl.push(ca % 10);
+                ca = Math.floor(ca / 10);
+            }
+            cl.reverse();
+            if (tx >= pows.length) {
+                for (let power = pows.length; power <= tx; power++) {
+                    let row = [];
+                    for (let digit = 0; digit <= 9; digit++) {
+                        row.push(pows[power-1][digit] * digit);
+                    }
+                    pows.push(row);
+                }
+            }
+            for (let i = 0; i < cl.length; i++) {
+                disar += pows[i+1][cl[i]];
+            }
+        }
+        if (disar == c) {
+            o.push(c);
+            if (o.length >= ct) {
+                break;
+            }
+        }
+        c++;
+    }
+    return o;
+}
+
+if (deepEqual(disarium(19),[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 89, 135,
+                             175, 518, 598, 1306, 1676, 2427, 2646798
+                           ])) {
+    process.stdout.write("Pass");
+} else {
+    process.stdout.write("FAIL");
+}
+process.stdout.write("\n");

challenge-174/roger-bell-west/javascript/ch-2.js

@@ -0,0 +1,108 @@
+#! /usr/bin/node
+
+"use strict"
+
+function deepEqual(a,b)
+{
+    if( (typeof a == 'object' && a != null) &&
+        (typeof b == 'object' && b != null) )
+    {
+        var count = [0,0]
+        for( var key in a) count[0]++
+        for( var key in b) count[1]++
+        if( count[0]-count[1] != 0) {return false}
+        for( var key in a)
+        {
+            if(!(key in b) || !deepEqual(a[key],b[key])) {return false}
+        }
+        for( var key in b)
+        {
+            if(!(key in a) || !deepEqual(b[key],a[key])) {return false}
+        }
+        return true
+    }
+    else
+    {
+        return a === b
+    }
+}
+
+function permutation2rank(perm) {
+    let n = 0;
+    let pp = [...perm];
+    pp.sort(function(a,b) {
+        return a-b;
+    });
+    let oi = [];
+    let l = 1;
+    for (let index = 2; index <= perm.length; index++) {
+        oi.push(l);
+        l *= index;
+    }
+    oi.reverse();
+    for (let index=0; index <= perm.length-2; index++) {
+        let base = new Map();
+        for (let i=0; i < pp.length; i++) {
+            base.set(pp[i],i);
+        }
+        n += oi[index] * base.get(perm[index]);
+        base.delete(perm[index]);
+        pp = [...base.keys()];
+        pp.sort(function(a,b) {
+            return a-b;
+        });
+    }
+    return n;
+}
+
+function rank2permutation(perm, rank0) {
+    let rank = rank0;
+    let pp = [...perm];
+    pp.sort(function(a,b) {
+        return a-b;
+    });
+    let o = [];
+    let oi = [];
+    let l = 1;
+    for (let index = 2; index <= perm.length; index++) {
+        oi.push(l);
+        l *= index;
+    }
+    oi.reverse();
+    for (let index=0; index <= perm.length-2; index++) {
+        let ix = Math.floor(rank / oi[index]);
+        o.push(pp[ix]);
+        pp = pp.filter(x => x != pp[ix]);
+        rank %= oi[index];
+    }
+    o.push(pp[0]);
+    return o;
+}
+
+if (permutation2rank([1,0,2]) == 2) {
+    process.stdout.write("Pass");
+} else {
+    process.stdout.write("FAIL");
+}
+process.stdout.write(" ");
+
+if (deepEqual(rank2permutation([0,1,2],1), [0,2,1])) {
+    process.stdout.write("Pass");
+} else {
+    process.stdout.write("FAIL");
+}
+process.stdout.write(" ");
+
+if (deepEqual(permutation2rank([2,0,3,1]),13)) {
+    process.stdout.write("Pass");
+} else {
+    process.stdout.write("FAIL");
+}
+process.stdout.write(" ");
+
+if (deepEqual(rank2permutation([1,3,2,0],7), [1,0,3,2])) {
+    process.stdout.write("Pass");
+} else {
+    process.stdout.write("FAIL");
+}
+process.stdout.write("\n");

challenge-174/roger-bell-west/kotlin/ch-1.kt

@@ -0,0 +1,52 @@
+import kotlin.math.*
+
+fun disarium(ct: Int): List<Int> {
+    var o = ArrayList<Int>()
+    var pows = ArrayList<ArrayList<Int>>()
+    pows.add(ArrayList(listOf(1,1,1,1,1,1,1,1,1,1)))
+    var c = 0
+    while (true) {
+        var disar = 0
+        if (c > 0) {
+            var ca = c
+            var cl = ArrayList<Int>()
+            var tx = 0
+            while (ca > 0) {
+                tx += 1
+                cl.add(ca % 10)
+                ca /= 10
+            }
+            cl.reverse()
+            if (tx >= pows.size) {
+                for (power in pows.size..tx) {
+                    var row = ArrayList<Int>()
+                    for (digit in 0..9) {
+                        row.add(pows[power-1][digit] * digit)
+                    }
+                    pows.add(row)
+                }
+            }
+            for (i in 0..cl.size-1) {
+                disar += pows[i+1][cl[i]]
+            }
+        }
+        if (disar == c) {
+            o.add(c)
+            if (o.size >= ct) {
+                break
+            }
+        }
+        c += 1
+    }
+    return o
+}
+
+fun main() {
+    if (disarium(19) == listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 89, 135,
+                               175, 518, 598, 1306, 1676, 2427, 2646798)) {
+        print("Pass")
+    } else {
+        print("FAIL")
+    }
+    println("")
+}

challenge-174/roger-bell-west/kotlin/ch-2.kt

@@ -0,0 +1,69 @@
+fun permutation2rank(perm: List<Int>): Int {
+    var n = 0
+    var pp = ArrayList(perm).sorted()
+    var oi = ArrayList<Int>()
+    var l = 1
+    for (index in 2..perm.size) {
+        oi.add(l)
+        l *= index
+    }
+    oi.reverse()
+    for (index in 0..perm.size-2) {
+        var base = mutableMapOf<Int,Int>()
+        for ((i,e) in pp.withIndex()) {
+            base[e]=i
+        }
+        n += oi[index] * base[perm[index]]!!;
+        base.remove(perm[index])
+        pp = base.keys.sorted()
+    }
+    return n
+}
+
+fun rank2permutation(perm: List<Int>, rank0: Int): List<Int> {
+    var rank = rank0
+    var pp = ArrayList(perm).sorted()
+    var o = ArrayList<Int>()
+    var oi = ArrayList<Int>()
+    var l = 1
+    for (index in 2..perm.size) {
+        oi.add(l)
+        l *= index
+    }
+    oi.reverse()
+    for (index in 0..perm.size-2) {
+        val ix = rank / oi[index]
+        o.add(pp[ix])
+        pp = pp.filter{it != pp[ix]}
+        rank %= oi[index]
+    }
+    o.add(pp[0])
+    return o
+}
+
+fun main() {
+    if (permutation2rank(listOf(1,0,2)) == 2) {
+        print("Pass")
+    } else {
+        print("FAIL")
+    }
+    print(" ")
+    if (rank2permutation(listOf(0,1,2),1) == listOf(0,2,1)) {
+        print("Pass")
+    } else {
+        print("FAIL")
+    }
+    print(" ")
+    if (permutation2rank(listOf(2,0,3,1)) == 13) {
+        print("Pass")
+    } else {
+        print("FAIL")
+    }
+    print(" ")
+    if (rank2permutation(listOf(1,3,2,0),7) == listOf(1,0,3,2)) {
+        print("Pass")
+    } else {
+        print("FAIL")
+    }
+    println(" ")
+}

challenge-174/roger-bell-west/perl/ch-1.pl

@@ -0,0 +1,52 @@
+#! /usr/bin/perl
+
+use strict;
+use warnings;
+use experimental 'signatures';
+
+use Test::More tests => 1;
+
+is_deeply(disarium(19),
+          [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 89, 135, 175, 518, 598, 1306, 1676,
+            2427, 2646798 ],
+          'example 1');
+
+sub disarium($ct) {
+  my @o;
+  my @pows=([(1) x 10]);
+  my $c = 0;
+  while (1) {
+    my $disar = 0;
+    if ($c > 0) {
+      my $ca = $c;
+      my @cl;
+      my $tx = 0;
+      while ($ca > 0) {
+        $tx++;
+        push @cl,$ca % 10;
+        $ca = int($ca/10);
+      }
+      @cl = reverse @cl;
+      if ($tx >= scalar @pows) {
+        foreach my $power ((scalar @pows)..$tx) {
+          my @row;
+          foreach my $digit (0..9) {
+            push @row,$pows[$power-1][$digit] * $digit
+          }
+          push @pows,\@row;
+        }
+      }
+      foreach my $i (0..$#cl) {
+        $disar += $pows[$i+1][$cl[$i]];
+      }
+    }
+    if ($disar == $c) {
+      push @o,$c;
+      if (scalar @o >= $ct) {
+        last;
+      }
+    }
+    $c++;
+  }
+  return \@o;
+}