Week 257

10 files changed, 710 insertions, 0 deletions

diff --git a/challenge-257/zapwai/c/ch-1.c b/challenge-257/zapwai/c/ch-1.c
new file mode 100644
index 0000000000..c2f565d4c5
--- /dev/null
+++ b/challenge-257/zapwai/c/ch-1.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+void printlist(int *a, int len) {
+  printf("(");
+  for (int i = 0; i < len - 1; i++) {
+    printf("%d, ", a[i]);    
+  }
+  printf("%d", a[len-1]);
+  printf(")\n");
+}
+
+void proc(int *ints, int len) {
+  int cnts[len];
+  for (int i = 0; i < len; i++) { cnts[i] = 0; }  
+  for (int i = 0; i < len; i++) {
+    for (int j = 0; j < len; j++) {    
+      if (ints[i] > ints[j]) {
+	cnts[i]++;
+      }
+    }
+  }
+  printf("Input: ");
+  printlist(ints, len);
+  printf("Output: ");
+  printlist(cnts, len);  
+}
+
+int main() {
+  int ints[] = {5, 2, 1, 6};
+  int len = sizeof(ints) / sizeof(int);
+  proc(ints, len);
+
+  int ints2[] = {2, 1, 0, 3};
+  int len2 = sizeof(ints2) / sizeof(int);
+  proc(ints2, len2);
+
+  int ints3[] = {0, 1};
+  int len3 = sizeof(ints3) / sizeof(int);
+  proc(ints3, len3);
+}
diff --git a/challenge-257/zapwai/c/ch-2.c b/challenge-257/zapwai/c/ch-2.c
new file mode 100644
index 0000000000..ac12cb84b4
--- /dev/null
+++ b/challenge-257/zapwai/c/ch-2.c
@@ -0,0 +1,134 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+bool is_echelon(int M, int N, int m[M][N]) {
+  int zcnt = 0;
+  for (int i = 0; i < M; i++) {
+    int cnt = 0;
+    for (int j = 0; j < N; j++) {
+      if (m[i][j] == 0) {
+	cnt++;
+      } else {
+	break;
+      }
+    }
+    if (cnt < zcnt) {
+      return false;
+    } else {
+      zcnt = cnt;
+    }
+  }
+  return true;
+}
+
+bool is_reduced(int M, int N, int m[M][N]) {
+  for (int i = 0; i < M; i++) {
+    for (int j = 0; j < N; j++) {
+      if (m[i][j] == 0) {
+	continue;
+      } else if (m[i][j] == 1) {
+	break;
+      } else {
+	return false;
+      }
+    }
+  }
+  int fv = N - M;
+  for (int j = 0; j < N - fv; j++) {
+    int cnt = 0;
+    for (int i = 0; i < M; i++) {
+      if (m[i][j] != 0) {
+	cnt++;
+      }
+    }
+    if (cnt > 1) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool check(int M, int N, int m[M][N]) {
+  return (is_echelon(M, N, m) && is_reduced(M, N, m));
+}
+
+void proc(int M, int N, int m[M][N]) {
+  printf("Input: M = {\n");
+  for (int i = 0; i < M; i++) {
+    printf("\t{");    
+    for (int j = 0; j < N - 1; j++) {
+      printf("%d, ", m[i][j]);
+    }
+    printf("%d", m[i][N - 1]);    
+    printf("}\n");
+  }
+  printf("\t}\n");
+  printf("Output: %d\n", check(M, N, m));
+}
+
+int main() {
+  const int M = 3;
+  const int N = 4;
+  int m[M][N] = {
+    {1,0,0,1},
+    {0,1,0,2},
+    {0,0,1,3}
+  };
+  proc(M, N, m);
+
+  const int M2 = 3;
+  const int N2 = 3;  
+  int m2[M2][N2] = {
+    {1, 1, 0},
+    {0, 1, 0},
+    {0, 0, 0}
+  };
+  proc(M2, N2, m2);
+
+  const int M3 = 4;
+  const int N3 = 5;  
+  int m3[M3][N3] = {    
+    {0, 1,-2, 0, 1},
+    {0, 0, 0, 1, 3},
+    {0, 0, 0, 0, 0},
+    {0, 0, 0, 0, 0}
+  };
+  proc(M3, N3, m3);  
+
+  const int M4 = 3;
+  const int N4 = 4;
+  int m4[M4][N4] = {
+    {1, 0, 0, 4},
+    {0, 1, 0, 7},
+    {0, 0, 1,-1}
+  };
+  proc(M4, N4, m4);  
+
+  const int M5 = 4;
+  const int N5 = 5;
+  int m5[M5][N5] = {
+    {0, 1,-2, 0, 1},
+    {0, 0, 0, 0, 0},
+    {0, 0, 0, 1, 3},
+    {0, 0, 0, 0, 0}
+  };
+  proc(M5, N5, m5);
+
+  const int M6 = 3;
+  const int N6 = 3;  
+  int m6[M6][N6] = {
+    {0, 1, 0},
+    {1, 0, 0},
+    {0, 0, 0}
+  };
+  proc(M6, N6, m6);
+
+  const int M7 = 3;
+  const int N7 = 4;  
+  int m7[M7][N7] = {
+    {4, 0, 0, 0},
+    {0, 1, 0, 7},
+    {0, 0, 1,-1}
+  };
+  proc(M7, N7, m7);
+}
diff --git a/challenge-257/zapwai/javascript/ch-1.js b/challenge-257/zapwai/javascript/ch-1.js
new file mode 100644
index 0000000000..f270d104bb
--- /dev/null
+++ b/challenge-257/zapwai/javascript/ch-1.js
@@ -0,0 +1,25 @@
+let ints = [5, 2, 1, 6];
+proc(ints);
+ints = [1, 2, 0, 3];
+proc(ints);
+ints = [0, 1];
+proc(ints);
+ints = [9, 4, 9, 2];
+proc(ints);
+
+function proc(ints) {
+    console.log("Input: ", ints);
+    let ans = [];
+
+    for (let i = 0; i < ints.length; i++) {
+	let cnt = 0;
+	for (let j = 0; j < ints.length; j++) {
+	    if (i == j) { continue; }
+	    if (ints[i] > ints[j]) {
+		cnt++;
+	    }
+	}
+	ans.push(cnt);
+    }
+    console.log("Output: ", ans);
+}
diff --git a/challenge-257/zapwai/javascript/ch-2.js b/challenge-257/zapwai/javascript/ch-2.js
new file mode 100644
index 0000000000..97c8bb9efa
--- /dev/null
+++ b/challenge-257/zapwai/javascript/ch-2.js
@@ -0,0 +1,123 @@
+let m0 = [
+    [1,0,0,1],
+    [0,1,0,2],
+    [0,0,1,3]
+];
+
+let m1 = [
+    [1, 1, 0],
+    [0, 1, 0],
+    [0, 0, 0]
+];
+
+
+
+let m2 = [
+    [0, 1,-2, 0, 1],
+    [0, 0, 0, 1, 3],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0]
+];
+
+
+let m3 = [
+    [1, 0, 0, 4],
+    [0, 1, 0, 7],
+    [0, 0, 1,-1]
+];
+
+
+
+let m4 = [
+    [0, 1,-2, 0, 1],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 1, 3],
+    [0, 0, 0, 0, 0]
+];
+
+
+let m5 = [
+    [0, 1, 0],
+    [1, 0, 0],
+    [0, 0, 0]
+];
+
+let m6 = [
+    [4, 0, 0, 0],
+    [0, 1, 0, 7],
+    [0, 0, 1,-1]
+];
+
+for (let m of [m0, m1, m2, m3, m4, m5, m6]) {
+    proc(m);
+}
+
+function proc(m) {
+    console.log("Input m = [");
+    for (let row of m) {
+	frow = "[";
+	for (let c of row) {
+	    frow += c + ", ";
+	}
+	let newrow = frow.slice(0, -2);
+	newrow += "]";
+	console.log(newrow);
+    }
+    console.log("]");
+    console.log("Output: ", check(m));
+}
+
+function is_reduced(m) {
+    // Check for leading ones
+    for (let row of m) {
+	for (let c of row) {
+	    if (c == 0) {
+		continue;
+	    }
+	    if (c == 1) {
+		break;
+	    }
+	    else {
+		return false;
+	    }
+	}
+    }
+    // Check for zero entries
+    let fv = m[0].length - m.length;
+    for (let j = 0; j < m[0].length - fv; j++) {
+	let cnt = 0;
+	for (let i = 0; i < m.length; i++) {
+	    if (m[i][j] != 0) {
+		cnt++;
+	    }
+	}
+	if (cnt > 1) {
+	    return false;
+	}
+    }
+    return true;
+}
+
+function is_echelon(m) {
+    let zcnt = 0;
+    for (let row of m) {
+	let cnt = 0;
+	for (let i = 0; i < row.length; i++) {
+	    if (row[i] == 0) {
+		cnt++;
+	    } else {
+		break;
+	    }
+	}
+	if (zcnt > cnt) {
+	    return false;
+	} else {
+	    zcnt = cnt;
+	}
+    }
+    return true;
+}
+
+function check(m) {
+    return is_reduced(m) && is_echelon(m);
+}
diff --git a/challenge-257/zapwai/perl/ch-1.pl b/challenge-257/zapwai/perl/ch-1.pl
new file mode 100644
index 0000000000..7a85f48c18
--- /dev/null
+++ b/challenge-257/zapwai/perl/ch-1.pl
@@ -0,0 +1,20 @@
+use v5.36;
+sub proc(@a) {
+    my @f = (0) x @a;
+    for my $i (0 .. $#a) {
+	for my $j (0 .. $#a) {
+	    $f[$i]++ if ($a[$i] > $a[$j]);
+	}
+    }
+    say "Input: \@a = (" . join(", ", @a) . ")";
+    say "Output: \@f = (" . join(", ", @f) . ")";
+}
+
+my @a = (5,2,1,6);
+proc(@a);
+
+@a = (1, 2, 0, 3);
+proc(@a);
+
+@a = (0, 1);
+proc(@a);
diff --git a/challenge-257/zapwai/perl/ch-2.pl b/challenge-257/zapwai/perl/ch-2.pl
new file mode 100644
index 0000000000..3149340071
--- /dev/null
+++ b/challenge-257/zapwai/perl/ch-2.pl
@@ -0,0 +1,113 @@
+use v5.36;
+
+sub is_echelon ($M) {
+    my ($w, $h) = (scalar @$M, scalar @{$$M[0]});
+    # The number of zeroes leading each row must not decrease.
+    my $zero_cnt = 0;
+    for my $i (0 .. $w - 1) {
+	my @row = @{$$M[$i]};
+	my $current_count = 0;
+	for my $j (0 .. $#row) {
+	    if ($row[$j] == 0) {
+		$current_count++;
+	    } else {
+		last;
+	    }
+	}
+	if ($current_count < $zero_cnt) {
+	    return 0;
+	} else {
+	    $zero_cnt = $current_count;
+	}
+    }
+    return 1;
+}
+
+sub is_reduced ($M) {
+    my ($r, $c) = (scalar @$M, scalar @{$$M[0]});
+    for my $i (0 .. $r - 1) {	# Check for leading ones.
+	my @row = @{$$M[$i]};
+	for my $j (0 .. $#row) {
+	    next if ($row[$j] == 0);
+	    last if ($row[$j] == 1);
+	    return 0;
+	}
+    }
+    # Check for nonzero entries above/below the 1. Skip the last fv cols.
+    my $fv = $c - $r; # Number of free vars (fv).     # Need to do case where this is negative
+    for my $j (0 .. $c - $fv - 1) {
+	my @col = map { ${${$M}[$_]}[$j] } (0 .. $r - 1);
+	my $cnt = 0;
+	for my $c (@col) {
+	    $cnt++ if ($c != 0); 
+	}
+	return 0 if ($cnt > 1);
+    }
+    return 1;
+}
+
+sub check ($M) { is_echelon($M) && is_reduced($M) }
+
+sub proc($M) {
+    say "Input: M = [";
+    say "\t[".join(", ", @$_)."]" for @$M; say "\t]";
+    say "Output: " . check($M);
+}
+
+my $M = [
+    [1,0,0,1],
+    [0,1,0,2],
+    [0,0,1,3]
+];
+
+proc($M);
+
+$M = [
+    [1, 1, 0],
+    [0, 1, 0],
+    [0, 0, 0]
+];
+
+proc($M);
+
+$M = [
+    [0, 1,-2, 0, 1],
+    [0, 0, 0, 1, 3],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0]
+];
+
+proc($M);
+
+$M = [
+    [1, 0, 0, 4],
+    [0, 1, 0, 7],
+    [0, 0, 1,-1]
+];
+
+proc($M);
+
+$M = [
+    [0, 1,-2, 0, 1],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 1, 3],
+    [0, 0, 0, 0, 0]
+];
+
+proc($M);
+
+$M = [
+    [0, 1, 0],
+    [1, 0, 0],
+    [0, 0, 0]
+];
+
+proc($M);
+
+$M = [
+    [4, 0, 0, 0],
+    [0, 1, 0, 7],
+    [0, 0, 1,-1]
+];
+
+proc($M);
diff --git a/challenge-257/zapwai/python/ch-1.py b/challenge-257/zapwai/python/ch-1.py
new file mode 100644
index 0000000000..e66ce9a3e8
--- /dev/null
+++ b/challenge-257/zapwai/python/ch-1.py
@@ -0,0 +1,25 @@
+def proc(ints):
+    cnts = [0]
+    while (len(cnts) < len(ints)):
+        cnts.append(0)
+    for i in range(len(ints)):
+        for j in range(len(ints)):
+            if (ints[i] > ints[j]):
+                cnts[i] += 1
+    print("Input: [", end='')
+    for i in range(len(ints) - 1):
+        print(f"{ints[i]}, ", end='')
+    print(f"{ints[len(ints)-1]}]")        
+    print("Output: [", end='')
+    for i in range(len(cnts) - 1):
+        print(f"{cnts[i]}, ", end='')
+    print(f"{cnts[len(cnts)-1]}]")
+        
+ints = [5,2,1,6]
+proc(ints)
+
+ints = [1,2,0,3]
+proc(ints)
+
+ints = [0,1]
+proc(ints)
diff --git a/challenge-257/zapwai/python/ch-2.py b/challenge-257/zapwai/python/ch-2.py
new file mode 100644
index 0000000000..932ddba1f7
--- /dev/null
+++ b/challenge-257/zapwai/python/ch-2.py
@@ -0,0 +1,97 @@
+def is_echelon(M):
+    (w, h) = (len(M), len(M[0]))
+    zero_cnt = 0
+    for i in range(w):
+        row = M[i]
+        curr_cnt = 0
+        for j in range(len(row)):
+            if (row[j] == 0):
+                curr_cnt += 1
+            else:
+                break
+        if (curr_cnt < zero_cnt):
+            return 0
+        else:
+            zero_cnt = curr_cnt
+    return 1
+
+def is_reduced(M):
+    (w, h) = (len(M), len(M[0]))
+    for i in range(w):
+        row = M[i]
+        for j in range(len(row)):
+            if row[j] == 0:
+                continue
+            if row[j] == 1:
+                break
+            return 0
+        fv = h - w
+    for j in range(len(row) - fv):
+        col = list(map(lambda x: M[x][j], range(w)))
+        cnt = 0
+        for k in col:
+            if (k != 0):
+                cnt += 1
+        if (cnt > 1):
+            return 0
+    return 1
+
+def check(M):
+    return is_echelon(M) and is_reduced(M)
+
+def proc(M):
+    print("Input: M = [")
+    for i in range(len(M)):
+        print("\t", M[i])
+    print("Output: ", check(M))
+
+M = [
+    [1,0,0,1],
+    [0,1,0,2],
+    [0,0,1,3]
+]
+proc(M)
+
+M = [
+    [1, 1, 0],
+    [0, 1, 0],
+    [0, 0, 0]
+]
+proc(M)
+
+M = [
+    [0, 1,-2, 0, 1],
+    [0, 0, 0, 1, 3],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 0, 0]
+]
+proc(M)
+
+M = [
+    [1, 0, 0, 4],
+    [0, 1, 0, 7],
+    [0, 0, 1,-1]
+]
+proc(M)
+
+M = [
+    [0, 1,-2, 0, 1],
+    [0, 0, 0, 0, 0],
+    [0, 0, 0, 1, 3],
+    [0, 0, 0, 0, 0]
+]
+proc(M)
+
+M = [
+    [0, 1, 0],
+    [1, 0, 0],
+    [0, 0, 0]
+]
+proc(M)
+
+M = [
+    [4, 0, 0, 0],
+    [0, 1, 0, 7],
+    [0, 0, 1,-1]
+]
+proc(M)
diff --git a/challenge-257/zapwai/rust/ch-1.rs b/challenge-257/zapwai/rust/ch-1.rs
new file mode 100644
index 0000000000..994d6ff150
--- /dev/null
+++ b/challenge-257/zapwai/rust/ch-1.rs
@@ -0,0 +1,22 @@
+fn proc(ints :&Vec<i32>) {
+    let mut cnts = vec![0; ints.len()];
+    for i in 0..ints.len() { cnts[i] = 0; }
+    for i in 0..ints.len() {
+	for j in 0..ints.len() {
+	    if ints[i] > ints[j] {
+		cnts[i] += 1;
+	    }
+	}
+    }
+    println!("Input : ints = {:?}", ints);
+    println!("Output: cnts = {:?}", cnts);
+}
+
+fn main() {
+    let ints = vec![5, 2, 1, 6];
+    proc(&ints);
+    let ints2 = vec![2, 1, 0, 3];
+    proc(&ints2);
+    let ints3 = vec![0, 1];
+    proc(&ints3);
+}
diff --git a/challenge-257/zapwai/rust/ch-2.rs b/challenge-257/zapwai/rust/ch-2.rs
new file mode 100644
index 0000000000..f3fb9257c5
--- /dev/null
+++ b/challenge-257/zapwai/rust/ch-2.rs
@@ -0,0 +1,112 @@
+#![allow(unused)]
+fn is_reduced(m : &Vec<Vec<i32>>) -> bool {
+    let (r, c) = (m.len(), m[0].len());
+    for i in 0 .. r {
+	for j in 0 .. c {
+	    if m[i][j] == 0 {
+		continue;
+	    } else if m[i][j] == 1 {
+		break;
+	    } else {
+		return false;
+	    }
+	}
+    }
+    let fv = c - r;
+    for j in 0 .. c-fv {
+	let mut cnt = 0;
+	for i in 0 .. r {
+	    if m[i][j] != 0 {
+		cnt += 1;
+	    }
+	}
+	if cnt > 1 {
+	    return false;
+	}
+    }
+    return true;
+}
+
+fn is_echelon(m : &Vec<Vec<i32>>) -> bool {
+    let (r, c) = (m.len(), m[0].len());
+    let mut zcnt = 0;
+    for i in 0 .. r {
+	let mut cnt = 0;
+	for j in 0 .. c {
+	    if (m[i][j] == 0) {
+		cnt += 1;
+	    } else {
+		break;
+	    }
+	}
+	if (cnt < zcnt) {
+	    return false;
+	} else {
+	    zcnt = cnt;
+	}
+    }
+    return true;
+}
+
+fn check(m : &Vec<Vec<i32>>) -> bool { return is_echelon(m) && is_reduced(m); }
+
+fn proc(m : &Vec<Vec<i32>>) {
+    println!("Input: M = [");
+    let mut i = 0;
+    loop {
+	println!("\t{:?}", m[i]);
+	i += 1;
+	if i == m.len() { break; }
+    }
+    println!("]");    
+
+    println!("Output: {}", check(m));    
+}
+
+fn main() {
+    let m1 = vec![
+	vec![1,0,0,1],
+	vec![0,1,0,2],
+	vec![0,0,1,3]
+    ];
+
+    let m2 = vec![
+	vec![1, 1, 0],
+	vec![0, 1, 0],
+	vec![0, 0, 0]
+    ];
+
+    let m3 = vec![
+	vec![0, 1,-2, 0, 1],
+	vec![0, 0, 0, 1, 3],
+	vec![0, 0, 0, 0, 0],
+	vec![0, 0, 0, 0, 0]
+    ];
+
+    let m4 = vec![
+	vec![1, 0, 0, 4],
+	vec![0, 1, 0, 7],
+	vec![0, 0, 1,-1]
+    ];
+
+    let m5 = vec![
+        vec![0, 1,-2, 0, 1],
+        vec![0, 0, 0, 0, 0],
+        vec![0, 0, 0, 1, 3],
+        vec![0, 0, 0, 0, 0]
+    ];
+
+    let m6 = vec![
+        vec![0, 1, 0],
+        vec![1, 0, 0],
+        vec![0, 0, 0]
+    ];
+
+    let m7 = vec![
+        vec![4, 0, 0, 0],
+        vec![0, 1, 0, 7],
+        vec![0, 0, 1,-1]
+    ];
+    
+    for k in [&m1, &m2, &m3, &m4, &m5, &m6, &m7] { proc(k); }    
+}