Add tasks for all the new languages

Task/Even-or-odd/8th/even-or-odd-1.8th

@@ -0,0 +1,4 @@
+: odd? \ n -- boolean
+    dup 1 n:band 1 n:= ;
+: even? \ n -- boolean
+    odd? not ;

Task/Even-or-odd/8th/even-or-odd-2.8th

@@ -0,0 +1,4 @@
+: even? \ n -- f
+  1 n:band not ;
+: odd? \ n -- f
+  even? not ;

Task/Even-or-odd/AntLang/even-or-odd.antlang

@@ -0,0 +1,2 @@
+odd: {x mod 2}
+even: {1 - x mod 2}

Task/Even-or-odd/Crystal/even-or-odd.crystal

@@ -0,0 +1,30 @@
+#Using bitwise shift
+  def isEven_bShift(n)
+    n == ((n >> 1) << 1)
+  end
+  def isOdd_bShift(n)
+    n != ((n >> 1) << 1)
+  end
+#Using modulo operator
+  def isEven_mod(n)
+    (n % 2) == 0
+  end
+  def isOdd_mod(n)
+    (n % 2) != 0
+  end
+# Using bitwise "and"
+  def isEven_bAnd(n)
+    (n & 1) ==  0
+  end
+  def isOdd_bAnd(n)
+    (n & 1) != 0
+  end
+
+puts isEven_bShift(7)
+puts isOdd_bShift(7)
+
+puts isEven_mod(12)
+puts isOdd_mod(12)
+
+puts isEven_bAnd(21)
+puts isOdd_bAnd(21)

Task/Even-or-odd/ERRE/even-or-odd.erre

@@ -0,0 +1,19 @@
+PROGRAM ODD_EVEN
+
+! works for -2^15 <= n% < 2^15
+
+FUNCTION ISODD%(N%)
+      ISODD%=(N% AND 1)<>0
+END FUNCTION
+
+! works for -2^38 <= n# <= 2^38
+FUNCTION ISODD#(N#)
+      ISODD#=N#<>2*INT(N#/2)
+END FUNCTION
+
+BEGIN
+  IF ISODD%(14) THEN PRINT("14 is odd") ELSE PRINT("14 is even") END IF
+  IF ISODD%(15) THEN PRINT("15 is odd") ELSE PRINT("15 is even") END IF
+  IF ISODD#(9876543210) THEN PRINT("9876543210 is odd") ELSE PRINT("9876543210 is even") END IF
+  IF ISODD#(9876543211) THEN PRINT("9876543211 is odd") ELSE PRINT("9876543211 is even") END IF
+END PROGRAM

Task/Even-or-odd/FreeBASIC/even-or-odd.freebasic

@@ -0,0 +1,19 @@
+' FB 1.05.0 Win64
+
+Dim n As Integer
+
+Do
+  Print "Enter an integer or 0 to finish : ";
+  Input "", n
+  If n = 0 Then
+    Exit Do
+  ElseIf n Mod 2 = 0 Then
+    Print "Your number is even"
+    Print
+  Else
+    Print "Your number is odd"
+    Print
+  End if
+Loop
+
+End

Task/Even-or-odd/Futhark/even-or-odd.futhark

@@ -0,0 +1 @@
+fun main(x: int): bool = (x & 1) == 0

Task/Even-or-odd/L++/even-or-odd.lpp

@@ -0,0 +1 @@
+(defn bool isEven (int x) (return (% x 2)))

Task/Even-or-odd/LC3-Assembly/even-or-odd.lc3

@@ -0,0 +1,21 @@
+      .ORIG      0x3000
+
+      LD         R0,NUM
+      AND        R1,R0,1
+      BRZ        EVEN
+
+      LEA        R0,ODD
+      BRNZP      DISP
+
+EVEN  LEA        R0,EVN
+
+DISP  PUTS
+
+      HALT
+
+NUM   .FILL      0x1C
+
+EVN   .STRINGZ   "EVEN\n"
+ODD   .STRINGZ   "ODD\n"
+
+      .END

Task/Even-or-odd/Lasso/even-or-odd.lasso

@@ -0,0 +1,5 @@
+define isoddoreven(i::integer) => {
+	#i % 2 ? return 'odd'
+	return 'even'
+}
+isoddoreven(12)

Task/Even-or-odd/Lingo/even-or-odd.lingo

@@ -0,0 +1,7 @@
+on even (n)
+  return n mod 2 = 0
+end
+
+on odd (n)
+  return n mode 2 <> 0
+end

Task/Even-or-odd/LiveCode/even-or-odd.livecode

@@ -0,0 +1,7 @@
+function odd n
+    return (n bitand 1) = 1
+end odd
+
+function notEven n
+    return (n mod 2) = 1
+end notEven

Task/Even-or-odd/NESL/even-or-odd.nesl

@@ -0,0 +1,4 @@
+function even(n) = mod(n, 2) == 0;
+
+% test the function by applying it to the first ten positive integers: %
+{even(n) : n in [1:11]};

Task/Even-or-odd/Nim/even-or-odd.nim

@@ -0,0 +1,14 @@
+# Least signficant bit:
+proc isOdd(i: int): bool = (i and 1) != 0
+proc isEven(i: int): bool = (i and 1) == 0
+
+# Modulo:
+proc isOdd2(i: int): bool = (i mod 2) != 0
+proc isEven2(i: int): bool = (i mod 2) == 0
+
+# Bit Shifting:
+proc isOdd3(n: int): bool = n != ((n shr 1) shl 1)
+proc isEven3(n: int): bool = n == ((n shr 1) shl 1)
+
+echo isEven(1)
+echo isOdd2(5)

Task/Even-or-odd/Oforth/even-or-odd.oforth

@@ -0,0 +1,2 @@
+12 isEven
+12 isOdd

Task/Even-or-odd/Phix/even-or-odd.phix

@@ -0,0 +1,3 @@
+for i = -5 to 5 do
+    ? {i, and_bits(i,1), remainder(i,2)}
+end for

Task/Even-or-odd/Ring/even-or-odd.ring

@@ -0,0 +1,5 @@
+size = 10
+for i = 1 to size
+    if i % 2 = 1 see "" + i + " is odd" + nl
+    else see "" + i + " is even" + nl ok
+next

Task/Even-or-odd/SSEM/even-or-odd.ssem

@@ -0,0 +1,15 @@
+11110000000000100000000000000000   0. -15 to c
+00000000000000110000000000000000   1. Test
+11110000000001100000000000000000   2. c to 15
+11110000000000100000000000000000   3. -15 to c
+00001000000001100000000000000000   4. c to 16
+00001000000000100000000000000000   5. -16 to c
+01110000000000010000000000000000   6. Sub. 14
+11110000000001100000000000000000   7. c to 15
+10110000000000010000000000000000   8. Sub. 13
+00000000000000110000000000000000   9. Test
+01110000000000000000000000000000  10. 14 to CI
+11110000000000100000000000000000  11. -15 to c
+00000000000001110000000000000000  12. Stop
+10000000000000000000000000000000  13. 1
+01000000000000000000000000000000  14. 2

Task/Even-or-odd/SequenceL/even-or-odd.sequencel

@@ -0,0 +1,2 @@
+even(x) := x mod 2 = 0;
+odd(x) := x mod 2 = 1;

Task/Even-or-odd/Sidef/even-or-odd-1.sidef

@@ -0,0 +1,3 @@
+var n = 42;
+say n.is_odd;       # false
+say n.is_even;      # true

Task/Even-or-odd/Sidef/even-or-odd-2.sidef

@@ -0,0 +1,2 @@
+func is_odd(n)  { n&1 == 1 };
+func is_even(n) { n&1 == 0 };

Task/Even-or-odd/Sidef/even-or-odd-3.sidef

@@ -0,0 +1,2 @@
+func is_odd(n)  { n%2 == 1 };
+func is_even(n) { n%2 == 0 };

Task/Even-or-odd/Swift/even-or-odd.swift

@@ -0,0 +1,13 @@
+func isEven(n:Int) -> Bool {
+
+    // Bitwise check
+    if (n & 1 != 0) {
+        return false
+    }
+
+    // Mod check
+    if (n % 2 != 0) {
+        return false
+    }
+    return true
+}

Task/Even-or-odd/Symsyn/even-or-odd.symsyn

@@ -0,0 +1,6 @@
+n : 23
+
+ if n bit 0
+    'n is odd' []
+ else
+    'n is even' []

Task/Even-or-odd/Ursa/even-or-odd.ursa

@@ -0,0 +1,7 @@
+decl int input
+set input (in int console)
+if (= (mod input 2) 1)
+        out "odd" endl console
+else
+        out "even" endl console
+end if

Task/Even-or-odd/jq/even-or-odd-1.jq

@@ -0,0 +1 @@
+def is_even: type == "number" and floor == 0 and . % 2 == 0;

Task/Even-or-odd/jq/even-or-odd-2.jq

@@ -0,0 +1 @@
+def is_odd: type == "number" and floor == 0 and . % 2 == 1;