Added java,oberon,pascal

7 files changed, 524 insertions, 0 deletions

diff --git a/challenge-239/deadmarshal/java/Ch1.java b/challenge-239/deadmarshal/java/Ch1.java
new file mode 100644
index 0000000000..059dea853d
--- /dev/null
+++ b/challenge-239/deadmarshal/java/Ch1.java
@@ -0,0 +1,23 @@
+import java.util.List;
+import java.lang.StringBuilder;
+
+public class Ch1 {
+  public static void main(String[] args) {
+    System.out.println(same_string(List.of("ab","c"),
+				   List.of("a","bc")));
+    System.out.println(same_string(List.of("ab","c"),
+				   List.of("ac","b")));
+    System.out.println(same_string(List.of("ab","cd","e"),
+				   List.of("abcde")));    
+  }
+
+  private static boolean same_string(List<String> list1,
+				     List<String> list2) {
+    StringBuilder sb1 = new StringBuilder();
+    StringBuilder sb2 = new StringBuilder();
+    for(var e : list1) sb1.append(e);
+    for(var e : list2) sb2.append(e);
+    return sb1.toString().equals(sb2.toString());
+  }
+}
+
diff --git a/challenge-239/deadmarshal/java/Ch2.java b/challenge-239/deadmarshal/java/Ch2.java
new file mode 100644
index 0000000000..2eecb3f108
--- /dev/null
+++ b/challenge-239/deadmarshal/java/Ch2.java
@@ -0,0 +1,33 @@
+import java.util.List;
+import java.util.ArrayList;
+
+public class Ch2 {
+  public static void main(String[] args) {
+    ArrayList<String> list1 =
+      new ArrayList<>(List.of("ad","bd","aaab","baa","badab"));
+    ArrayList<String> list2 =
+      new ArrayList<>(List.of("a","b","c","ab","ac","bc","abc"));
+    ArrayList<String> list3 =
+      new ArrayList<>(List.of("cc","acd","b","ba","bac","bad","ac","d"));
+    System.out.println(consistent_strings(list1,"ab"));
+    System.out.println(consistent_strings(list2,"abc"));
+    System.out.println(consistent_strings(list3,"cad"));
+  }
+
+  private static int consistent_strings(List<String> list,
+					String allowed) {
+    int count = 0;
+    for(var str : list) {
+      boolean b = true;
+      for(var c : str.toCharArray()) {
+	if(allowed.indexOf(c) == -1) {
+	  b = false;
+	  break;
+	}
+      }
+      if(b) count++;
+    }
+    return count;
+  }
+}
+
diff --git a/challenge-239/deadmarshal/oberon/Ch1.Mod b/challenge-239/deadmarshal/oberon/Ch1.Mod
new file mode 100644
index 0000000000..22fc7523d5
--- /dev/null
+++ b/challenge-239/deadmarshal/oberon/Ch1.Mod
@@ -0,0 +1,51 @@
+MODULE Ch1;
+
+  IMPORT Out,DS := DynamicString;
+
+  VAR
+    A1,A2,A3,A4:ARRAY 2 OF DS.DynamicString;
+    A5:ARRAY 3 OF DS.DynamicString;
+    A6:ARRAY 1 OF DS.DynamicString;
+    
+  PROCEDURE Init;
+    VAR i:LONGINT;
+  BEGIN
+    FOR i := 0 TO LEN(A1)-1 DO
+      A1[i] := DS.Create();
+      A2[i] := DS.Create();
+      A3[i] := DS.Create();
+      A4[i] := DS.Create();
+    END;
+    FOR i := 0 TO LEN(A5)-1 DO A5[i] := DS.Create() END;
+    FOR i := 0 TO LEN(A6)-1 DO A6[i] := DS.Create() END;
+    DS.Append(A1[0],"ab"); DS.Append(A1[1],"c");
+    DS.Append(A2[0],"a");  DS.Append(A2[1],"bc");
+    DS.Append(A3[0],"ab"); DS.Append(A3[1],"c");
+    DS.Append(A4[0],"ac"); DS.Append(A4[1],"b");
+    DS.Append(A5[0],"ab"); DS.Append(A5[1],"cd"); DS.Append(A5[2],"e");
+    DS.Append(A6[0],"abcde");
+  END Init;
+
+  PROCEDURE SameString(VAR arr1,arr2:ARRAY OF DS.DynamicString):BOOLEAN;
+    VAR
+      i:LONGINT;
+      s1,s2:DS.DynamicString;
+  BEGIN
+    s1 := DS.Create(); s2 := DS.Create();
+    FOR i := 0 TO LEN(arr1)-1 DO DS.Append(s1,arr1[i].data^) END;
+    FOR i := 0 TO LEN(arr2)-1 DO DS.Append(s2,arr2[i].data^) END;
+    RETURN DS.Equals(s1,s2)
+  END SameString;
+
+  PROCEDURE PrintBool(b:BOOLEAN);
+  BEGIN
+    IF b THEN Out.String("TRUE"); Out.Ln ELSE Out.String("FALSE"); Out.Ln END
+  END PrintBool;
+  
+BEGIN
+  Init;
+  PrintBool(SameString(A1,A2));
+  PrintBool(SameString(A3,A4));
+  PrintBool(SameString(A5,A6));
+END Ch1.
+
diff --git a/challenge-239/deadmarshal/oberon/Ch2.Mod b/challenge-239/deadmarshal/oberon/Ch2.Mod
new file mode 100644
index 0000000000..1b81a03c20
--- /dev/null
+++ b/challenge-239/deadmarshal/oberon/Ch2.Mod
@@ -0,0 +1,58 @@
+MODULE Ch2;
+
+  IMPORT Out,DS := DynamicString;
+
+  VAR 
+    A1:ARRAY 5 OF DS.DynamicString;
+    A2:ARRAY 7 OF DS.DynamicString;
+    A3:ARRAY 8 OF DS.DynamicString;
+    
+  PROCEDURE Init;
+    VAR i:LONGINT;
+  BEGIN
+    FOR i := 0 TO LEN(A1)-1 DO A1[i] := DS.Create() END;
+    FOR i := 0 TO LEN(A2)-1 DO A2[i] := DS.Create() END;
+    FOR i := 0 TO LEN(A3)-1 DO A3[i] := DS.Create() END;
+    DS.Append(A1[0],"ad"); DS.Append(A1[1],"bd"); DS.Append(A1[2],"aaab");
+    DS.Append(A1[3],"baa"); DS.Append(A1[4],"badab");
+    DS.Append(A2[0],"a"); DS.Append(A2[1],"b"); DS.Append(A2[2],"c");
+    DS.Append(A2[3],"ab"); DS.Append(A2[4],"ac"); DS.Append(A2[5],"bc");
+    DS.Append(A2[6],"abc");
+    DS.Append(A3[0],"cc"); DS.Append(A3[1],"acd"); DS.Append(A3[2],"b");
+    DS.Append(A3[3],"ba"); DS.Append(A3[4],"bac"); DS.Append(A3[5],"bad");
+    DS.Append(A3[6],"ac"); DS.Append(A3[7],"d");
+  END Init;
+
+  PROCEDURE Pos(VAR str:ARRAY OF CHAR;ch:CHAR):LONGINT;
+    VAR i:LONGINT;
+  BEGIN
+    FOR i := 0 TO LEN(str)-1 DO IF str[i] = ch THEN RETURN i END END;
+    RETURN -1
+  END Pos;
+  
+  PROCEDURE ConsistentStrings(VAR arr:ARRAY OF DS.DynamicString;
+			      allowed:ARRAY OF CHAR):LONGINT;
+    VAR
+      i,j,count:LONGINT;
+      b:BOOLEAN;
+  BEGIN
+    count := 0;
+    FOR i := 0 TO LEN(arr)-1 DO
+      b := TRUE; j := 0;
+      LOOP
+	IF j >= DS.Length(arr[i]) THEN EXIT END;
+	IF Pos(allowed,arr[i].data[j]) = -1 THEN b := FALSE; EXIT END;
+	INC(j);
+      END;
+      IF b THEN INC(count) END
+    END;
+    RETURN count
+  END ConsistentStrings;
+  
+BEGIN
+  Init;
+  Out.Int(ConsistentStrings(A1,"ab"),0); Out.Ln;
+  Out.Int(ConsistentStrings(A2,"abc"),0); Out.Ln;
+  Out.Int(ConsistentStrings(A3,"cad"),0); Out.Ln;
+END Ch2.
+
diff --git a/challenge-239/deadmarshal/oberon/DynamicString.Mod b/challenge-239/deadmarshal/oberon/DynamicString.Mod
new file mode 100644
index 0000000000..e39dbe7e17
--- /dev/null
+++ b/challenge-239/deadmarshal/oberon/DynamicString.Mod
@@ -0,0 +1,288 @@
+MODULE DynamicString;
+
+  IMPORT Out,Strings;
+    
+  CONST
+    InitialSize = 256;
+
+  TYPE
+    String* = POINTER TO ARRAY OF CHAR;
+    DynamicString* = POINTER TO DynamicStringDesc;
+    DynamicStringDesc = RECORD
+      data*:POINTER TO ARRAY OF CHAR;
+      length,capacity:LONGINT;
+    END;
+
+  (* Private *)
+  PROCEDURE IsSpace(ch: CHAR): BOOLEAN;
+  BEGIN
+    RETURN (ch = ' ') OR (ch = CHR(9)) OR
+      (ch = CHR(11)) OR (ch = CHR(12)) OR
+      (ch = CHR(13))
+  END IsSpace;
+
+  (* Public *)
+  PROCEDURE Create*():DynamicString;
+    VAR ret:DynamicString;
+  BEGIN
+    NEW(ret);
+    NEW(ret.data,InitialSize);
+    ret.length := 0;
+    ret.capacity := InitialSize;
+    RETURN ret
+  END Create;
+
+  PROCEDURE Clear*(ds:DynamicString);
+  BEGIN
+    ASSERT(ds # NIL);
+    ds.data[0] := 0X;
+    ds.length := 0;
+    ds.capacity := 0;
+  END Clear;
+  
+  PROCEDURE Resize(VAR ds:DynamicString;minsize:LONGINT);
+    VAR ret:DynamicString;
+  BEGIN
+    ASSERT(ds # NIL);
+    IF minsize >= ds.capacity THEN
+      REPEAT ds.capacity := ds.capacity * 2 UNTIL ds.capacity > minsize;
+      NEW(ret);
+      NEW(ret.data,ds.capacity);
+      ret.length := ds.length;
+      ret.capacity := ds.capacity;
+      COPY(ds.data^,ret.data^);
+      ds := ret;
+    END;
+  END Resize;
+
+  PROCEDURE Put*(VAR ds:DynamicString;ch:CHAR;at:LONGINT);
+  BEGIN
+    ASSERT(ds # NIL);
+    IF at+1 >= ds.capacity THEN Resize(ds,at+1) END;
+    ds.data[at] := ch;
+  END Put;
+
+  PROCEDURE Get*(VAR ds:DynamicString;at:LONGINT):CHAR;
+  BEGIN
+    ASSERT(ds # NIL);
+    IF at+1 > ds.length THEN RETURN 0X ELSE RETURN ds.data[at] END
+  END Get;
+
+  PROCEDURE AppendCharacter*(VAR ds:DynamicString;ch:CHAR);
+  BEGIN
+    ASSERT(ds # NIL);
+    IF ch # 0X THEN
+      IF ds.length+2 >= ds.length THEN Resize(ds,ds.length+2) END;
+      ds.data[ds.length] := ch;
+      ds.data[ds.length+1] := 0X;
+      INC(ds.length);
+    END;
+  END AppendCharacter;
+
+  PROCEDURE Append*(VAR ds:DynamicString;s:ARRAY OF CHAR);
+    VAR slength:LONGINT;
+  BEGIN
+    ASSERT(ds # NIL);
+    slength := Strings.Length(s);
+    IF ds.length+slength+1 >= ds.length THEN Resize(ds,ds.length+slength+1) END;
+    Strings.Append(s,ds.data^);
+    ds.length := ds.length + slength
+  END Append;
+
+  PROCEDURE Extract*(VAR ds:DynamicString;offset,len:LONGINT):String;
+    VAR
+      s:String;
+      i:LONGINT;
+  BEGIN
+    ASSERT(ds # NIL);
+    IF offset < ds.length THEN
+      IF offset+len > ds.length THEN len := ds.length - offset END;
+      NEW(s,len+1);
+      FOR i := 0 TO len-1 DO
+	s[i] := ds.data[i+offset]
+      END;
+      s[len] := 0X;
+    ELSE
+      NEW(s,1); s[0] := 0X;
+    END;
+    RETURN s
+  END Extract; 
+
+  PROCEDURE Length*(VAR ds:DynamicString):LONGINT;
+  BEGIN
+    ASSERT(ds # NIL);
+    RETURN ds.length
+  END Length;
+
+  PROCEDURE ToArrOfChar*(VAR ds:DynamicString):String;
+    VAR s:String;
+  BEGIN
+    ASSERT(ds # NIL);
+    NEW(s,ds.length+1);
+    COPY(ds.data^,s^);
+    RETURN s
+  END ToArrOfChar;
+
+  PROCEDURE FromArrOfChar*(VAR s:String):DynamicString;
+    VAR
+      ret:DynamicString;
+      len:LONGINT;
+  BEGIN
+    ASSERT(s # NIL);
+    len := Strings.Length(s^);
+    NEW(ret);
+    ret.length := len;
+    ret.capacity := len;
+    NEW(ret.data,ret.capacity);
+    COPY(s^,ret.data^);
+    RETURN ret
+  END FromArrOfChar;
+
+  PROCEDURE Compare*(VAR ds1,ds2:DynamicString):LONGINT;
+    VAR
+      i,j:LONGINT;
+      c1,c2:CHAR;
+  BEGIN
+    ASSERT((ds1 # NIL) & (ds2 # NIL));
+    i := 0;
+    j := 0;
+    REPEAT
+      c1 := ds1.data[i];
+      c2 := ds2.data[i];
+      IF c1 = 0X THEN RETURN ORD(c1) - ORD(c2) END;
+      INC(i);
+      INC(j);
+    UNTIL c1 # c2;
+    RETURN ORD(c1) - ORD(c2)
+  END Compare;
+
+  PROCEDURE ToUpper*(VAR ds:DynamicString);
+    VAR i:LONGINT;
+  BEGIN
+    ASSERT((ds # NIL) & (ds.length > 0));
+    FOR i := 0 TO ds.length-1 DO
+      IF (ds.data[i] >= "a") & (ds.data[i] <= "z") THEN
+	ds.data[i] := CHR(ORD(ds.data[i]) - ORD("a") + ORD("A"));
+      END;
+    END;
+  END ToUpper;
+
+  PROCEDURE ToLower*(VAR ds:DynamicString);
+    VAR i:LONGINT;
+  BEGIN
+    ASSERT((ds # NIL) & (ds.length > 0));
+    FOR i := 0 TO ds.length-1 DO
+      IF (ds.data[i] >= "A") & (ds.data[i] <= "Z") THEN
+	ds.data[i] := CHR(ORD(ds.data[i]) + ORD("a") - ORD("A"));
+      END;
+    END;
+  END ToLower;
+
+  PROCEDURE TrimLeft*(VAR ds:DynamicString);
+    VAR i,j:LONGINT;
+  BEGIN
+    i := 0; j := 0;
+    WHILE (IsSpace(ds.data[i])) & (i < Length(ds)) DO INC(i) END;
+    WHILE ds.data[i] # 0X DO
+      ds.data[j] := ds.data[i];
+      INC(i);
+      INC(j);
+    END;
+    ds.data[j] := 0X;
+  END TrimLeft;
+
+  PROCEDURE TrimRight*(VAR ds:DynamicString);
+    VAR i,len:LONGINT;
+  BEGIN
+    len := Length(ds);
+    i := len;
+    WHILE (IsSpace(ds.data[i])) & (i >= 0) DO DEC(i) END;
+    WHILE i <= len DO ds.data[i] := 0X; INC(i) END;
+  END TrimRight;
+
+  PROCEDURE Trim*(VAR ds:DynamicString);
+  BEGIN
+    TrimLeft(ds);
+    TrimRight(ds)
+  END Trim;
+  
+  PROCEDURE Reverse*(VAR ds:DynamicString);
+    VAR
+      i,length,middle:LONGINT;
+      temp:CHAR;
+  BEGIN
+    length := Length(ds);
+    middle := length DIV 2;
+    FOR i := 0 TO middle-1 DO
+      temp := ds.data[i];
+      ds.data[i] := ds.data[length-i-1];
+      ds.data[length-i-1] := temp;
+    END;
+  END Reverse;
+
+  PROCEDURE EndsWith*(VAR ds:DynamicString;str:ARRAY OF CHAR):BOOLEAN;
+    VAR
+      i,dslen,strlen:LONGINT;
+  BEGIN
+    dslen := Length(ds);
+    strlen := Strings.Length(str);
+    IF strlen > dslen THEN RETURN FALSE END;
+    FOR i := 0 TO strlen DO
+      IF ds.data[dslen-i] # str[strlen-i] THEN RETURN FALSE END
+    END;
+    RETURN TRUE
+  END EndsWith;
+
+  PROCEDURE Equals*(VAR ds1,ds2:DynamicString):BOOLEAN;
+    VAR
+      i,ds1len,ds2len:LONGINT;
+  BEGIN
+    ds1len := Length(ds1);
+    ds2len := Length(ds2);
+    FOR i := 0 TO Length(ds1) DO
+      IF ds1.data[i] # ds2.data[i] THEN RETURN FALSE END
+    END;
+    RETURN TRUE
+  END Equals;
+  
+BEGIN
+END DynamicString.
+
+(* PROCEDURE Copy(self:String); *)
+(* PROCEDURE Format(self:String); *)
+(* PROCEDURE IsNullOrEmpty(self:String); *)
+(* PROCEDURE IsNullOrWhiteSpace(self:String); *)
+(* PROCEDURE Join(self:String); *)
+(* PROCEDURE Parse(self:String); *)
+(* PROCEDURE ToBoolean(self:String); *)
+(* PROCEDURE ToDouble(self:String); *)
+(* PROCEDURE ToExtended(self:String); *)
+(* PROCEDURE ToInt64(self:String); *)
+(* PROCEDURE ToInteger(self:String); *)
+(* PROCEDURE ToSingle(self:String); *)
+(* PROCEDURE CompareTo(self:String); *)
+(* PROCEDURE Contains(self:String); *)
+(* PROCEDURE CopyTo(self:String); *)
+(* PROCEDURE CountChar(self:String); *)
+(* PROCEDURE DeQuotedString(self:String); *)
+(* PROCEDURE EndsWidth(self:String); *)
+(* PROCEDURE GetHashCode(self:String); *)
+(* PROCEDURE IndexOf(self:String); *)
+(* PROCEDURE IndexOfQuoted(self:String); *)
+(* PROCEDURE IndexOfAny(self:String); *)
+(* PROCEDURE IndexOfAnyUnquoted(self:String); *)
+(* PROCEDURE Insert(self:String); *)
+(* PROCEDURE IsDelimiter(self:String); *)
+(* PROCEDURE IsEmpty(self:String); *)
+(* PROCEDURE LastDelimiter(self:String); *)
+(* PROCEDURE LastIndexOf(self:String); *)
+(* PROCEDURE LastIndexOfAny(self:String); *)
+(* PROCEDURE PadLeft(self:String); *)
+(* PROCEDURE PadRight(self:String); *)
+(* PROCEDURE QuotedString(self:String); *)
+(* PROCEDURE Remove(self:String); *)
+(* PROCEDURE Replace(self:String); *)
+(* PROCEDURE Split(self:String); *)
+(* PROCEDURE StartsWith(self:String); *)
+(* PROCEDURE Substring(self:String); *)
+
diff --git a/challenge-239/deadmarshal/pascal/ch1.pas b/challenge-239/deadmarshal/pascal/ch1.pas
new file mode 100644
index 0000000000..5b423234bb
--- /dev/null
+++ b/challenge-239/deadmarshal/pascal/ch1.pas
@@ -0,0 +1,31 @@
+program Ch1;
+
+{$mode objfpc}
+uses
+  SysUtils,Types;
+
+var
+  A1,A2,A3,A4,A5,A6:TStringDynArray;
+
+function SameString(var Arr1,Arr2:TStringDynArray):Boolean;
+var
+  I:Integer;
+  S1,S2:AnsiString;
+begin
+  for I := Low(Arr1) to High(Arr1) do S1 := S1 + Arr1[I];
+  for I := Low(Arr2) to High(Arr2) do S2 := S2 + Arr2[I];
+  Result := S1 = S2;
+end;
+
+begin
+  A1 := ['ab','c'];
+  A2 := ['a','bc'];
+  A3 := ['ab','c'];
+  A4 := ['ac','b'];
+  A5 := ['ab','cd','e'];
+  A6 := ['abcde'];
+  WriteLn(SameString(A1,A2));
+  WriteLn(SameString(A3,A4));
+  WriteLn(SameString(A5,A6));
+end.
+  
diff --git a/challenge-239/deadmarshal/pascal/ch2.pas b/challenge-239/deadmarshal/pascal/ch2.pas
new file mode 100644
index 0000000000..4405514a4d
--- /dev/null
+++ b/challenge-239/deadmarshal/pascal/ch2.pas
@@ -0,0 +1,40 @@
+program Ch2;
+
+{$mode objfpc}
+uses
+  SysUtils,Types;
+
+var
+  A1,A2,A3:TStringDynArray;
+
+function ConsistentStrings(var Arr:TStringDynArray;
+			   Allowed:AnsiString):Integer;
+var
+  I,J:Integer;
+  B:Boolean;
+begin
+  Result := 0;
+  for I := Low(Arr) to High(Arr) do
+  begin
+    B := True;
+    for J := Low(Arr[I]) to High(Arr[I]) do
+    begin
+      if not Allowed.Contains(Arr[I][J]) then
+      begin
+	B := False;
+	break
+      end
+    end;
+    if B then Inc(Result);
+  end
+end;
+
+begin
+  A1 := ['ad','bd','aaab','baa','badab'];
+  A2 := ['a','b','c','ab','ac','bc','abc'];
+  A3 := ['cc','acd','b','ba','bac','bad','ac','d'];
+  WriteLn(ConsistentStrings(A1,'ab'));
+  WriteLn(ConsistentStrings(A2,'abc'));
+  WriteLn(ConsistentStrings(A3,'cad'));
+end.
+