Data commit

Task/Middle-three-digits/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Middle_three_digits

Task/Middle-three-digits/00-TASK.txt

@@ -0,0 +1,13 @@
+;Task:
+Write a function/procedure/subroutine that is called with an integer value and returns the middle three digits of the integer if possible or a clear indication of an error if this is not possible.
+
+Note: The order of the middle digits should be preserved.
+
+Your function should be tested with the following values; the first line should return valid answers, those of the second line should return clear indications of an error:
+<pre>
+123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345
+1, 2, -1, -10, 2002, -2002, 0
+</pre>
+Show your output on this page.
+<br><br>
+

Task/Middle-three-digits/11l/middle-three-digits.11l

@@ -0,0 +1,13 @@
+F middle_three_digits(i)
+   V s = String(abs(i))
+   assert(s.len >= 3 & s.len % 2 == 1, ‘Need odd and >= 3 digits’)
+   R s[s.len I/ 2 - 1 .+ 3]
+
+V passing = [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345]
+V failing = [1, 2, -1, -10, 2002, -2002, 0]
+L(x) passing [+] failing
+   X.try
+      V answer = middle_three_digits(x)
+      print(‘middle_three_digits(#.) returned: #.’.format(x, answer))
+   X.catch AssertionError error
+      print(‘middle_three_digits(#.) returned error: ’.format(x)‘’String(error))

Task/Middle-three-digits/ALGOL-68/middle-three-digits.alg

@@ -0,0 +1,63 @@
+# we define a UNION MODE so that our middle 3 digits PROC can #
+# return either an integer on success or a error message if   #
+# the middle 3 digits couldn't be extracted                   #
+MODE EINT = UNION( INT # success value #, STRING # error message # );
+# PROC to return the middle 3 digits of an integer.           #
+# if this is not possible, an error message is returned       #
+# instead                                                     #
+PROC middle 3 digits = ( INT number ) EINT:
+BEGIN
+    # convert the absolute value of the number to a string with the  #
+    # minumum possible number characters                             #
+    STRING digits     = whole( ABS number, 0 );
+    INT    len        = UPB digits;
+    IF   len < 3
+    THEN
+        # number has less than 3 digits #
+        # return an error message       #
+        "number must have at least three digits"
+    ELIF ( len MOD 2 ) = 0
+    THEN
+        # the number has an even number of digits #
+        # return an error message                 #
+        "number must have an odd number of digits"
+    ELSE
+        # the number is suitable for extraction of the middle 3 digits #
+        INT first digit pos = 1 + ( ( len - 3 ) OVER 2 );
+        # the result is the integer value of the three digits          #
+        ( ( ( ABS digits[ first digit pos     ] - ABS "0" ) * 100 )
+        + ( ( ABS digits[ first digit pos + 1 ] - ABS "0" ) *  10 )
+        + ( ( ABS digits[ first digit pos + 2 ] - ABS "0" )       )
+        )
+    FI
+END; # middle 3 digits #
+
+main: (
+    # test the middle 3 digits PROC #
+    []INT test values = (    123,  12345, 1234567, 987654321
+                        ,  10001, -10001,    -123,      -100
+                        ,    100, -12345
+                          # the following values should fail #
+                        , 1, 2, -1, -10, 2002, -2002, 0
+                        );
+    FOR test number FROM LWB test values TO UPB test values
+    DO
+        CASE middle 3 digits( test values[ test number ] )
+        IN
+        ( INT     success value ):    # got the middle 3 digits #
+            printf( ( $ 11z-d, " : ", 3d $
+                    , test values[ test number ]
+                    , success value
+                    )
+                  )
+            ,
+        ( STRING  error message  ):    # got an error message   #
+            printf( ( $ 11z-d, " : ", n( UPB error message )a $
+                    , test values[ test number ]
+                    , error message
+                    )
+                  )
+        ESAC;
+        print( ( newline ) )
+    OD
+)

Task/Middle-three-digits/ALGOL-W/middle-three-digits.alg

@@ -0,0 +1,48 @@
+begin
+    % record structure that will be used to return the middle 3 digits of a number   %
+    % if the middle three digits can't be determined, isOk will be false and message %
+    % will contain an error message                                                  %
+    % if the middle 3 digts can be determined, middle3 will contain the middle 3     %
+    % digits and isOk will be true                                                   %
+    record MiddleThreeDigits ( integer middle3; logical isOk; string(80) message );
+
+    % finds the middle3 digits of a number or describes why they can't be found      %
+    reference(MiddleThreeDigits) procedure findMiddleThreeDigits ( integer value number ) ;
+        begin
+            integer n, digitCount, d;
+
+            n          := abs( number );
+            % count the number of digits the number has %
+            digitCount := if n = 0 then 1 else 0;
+            d          := n;
+            while d > 0 do begin
+                digitCount := digitCount + 1;
+                d          := d div 10
+            end while_d_gt_0 ;
+            if      digitCount < 3        then MiddleThreeDigits( 0, false, "Number must have at least 3 digits"       )
+            else if not odd( digitCount ) then MiddleThreeDigits( 0, false, "Number must have an odd number of digits" )
+            else begin
+                % can find the middle three digits %
+                integer m3;
+                m3 := n;
+                for d := 1 until ( digitCount - 3 ) div 2 do m3 := m3 div 10;
+                MiddleThreeDigits( m3 rem 1000, true, "" )
+            end
+        end findMiddleThreeDigits ;
+
+    % test the findMiddleThreeDigits procedure %
+    for n := 123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0 do begin
+        reference(MiddleThreeDigits) m3;
+        i_w := 10; s_w := 0; % set output formating %
+        m3 := findMiddleThreeDigits( n );
+        write( n, ": " );
+        if not isOk(m3) then writeon( message(m3) )
+        else begin
+            % as we return the middle three digits as an integer, we must manually 0 pad %
+            if middle3(m3) < 100 then writeon( "0" );
+            if middle3(m3) <  10 then writeon( "0" );
+            writeon( i_w := 1, middle3(m3) )
+        end
+    end for_n
+
+end.

Task/Middle-three-digits/ATS/middle-three-digits.ats

@@ -0,0 +1,120 @@
+(* ****** ****** *)
+//
+#include
+"share/atspre_staload.hats"
+#include
+"share/HATS/atspre_staload_libats_ML.hats"
+//
+(* ****** ****** *)
+//
+extern
+fun
+int2digits(x: int): list0(int)
+//
+(* ****** ****** *)
+
+implement
+int2digits(x) =
+loop(x, list0_nil) where
+{
+//
+fun
+loop
+(
+ x: int, res: list0(int)
+) : list0(int) =
+  if x > 0 then loop(x/10, list0_cons(x%10, res)) else res
+//
+} (* end of [int2digits] *)
+
+(* ****** ****** *)
+
+extern
+fun
+Middle_three_digits(x: int): void
+
+(* ****** ****** *)
+
+implement
+Middle_three_digits
+  (x0) = let
+//
+val x1 =
+(
+if x0 >= 0 then x0 else ~x0
+) : int
+//
+fun
+skip
+(
+ds: list0(int), k: int
+) : list0(int) =
+  if k > 0 then skip(ds.tail(), k-1) else ds
+//
+val ds =
+  int2digits(x1)
+//
+val n0 = length(ds)
+//
+in
+//
+if
+(n0 <= 2)
+then
+(
+println! ("Middle-three-digits(", x0, "): Too small!")
+)
+else
+(
+if
+(n0 % 2 = 0)
+then
+(
+println!
+(
+"Middle-three-digits(", x0, "): Even number of digits!"
+)
+)
+else let
+  val ds =
+    skip(ds, (n0-3)/2)
+  val-list0_cons(d1, ds) = ds
+  val-list0_cons(d2, ds) = ds
+  val-list0_cons(d3, ds) = ds
+in
+  println! ("Middle-three-digits(", x0, "): ", d1, d2, d3)
+end // end of [else]
+)
+//
+end // end of [Middle_three_digits]
+
+(* ****** ****** *)
+
+implement
+main0() =
+{
+//
+val
+thePassing =
+g0ofg1
+(
+$list{int}
+(
+  123
+, 12345
+, 1234567
+, 987654321
+, 10001, ~10001
+, ~123, ~100, 100, ~12345
+)
+)
+val
+theFailing =
+g0ofg1($list{int}(1, 2, ~1, ~10, 2002, ~2002, 0))
+//
+val () = thePassing.foreach()(lam x => Middle_three_digits(x))
+val () = theFailing.foreach()(lam x => Middle_three_digits(x))
+//
+} (* end of [main0] *)
+
+(* ****** ****** *)

Task/Middle-three-digits/AWK/middle-three-digits.awk

@@ -0,0 +1,28 @@
+#!/bin/awk -f
+# use as: awk -f middle_three_digits.awk
+
+BEGIN {
+	n = split("123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345 1 2 -1 -10 2002 -2002 0", arr)
+
+	for (i=1; i<=n; i++) {
+		if (arr[i] !~ /^-?[0-9]+$/) {
+			printf("%10s : invalid input: not a number\n", arr[i])
+			continue
+		}
+
+		num = arr[i]<0 ? -arr[i]:arr[i]
+		len = length(num)
+
+		if (len < 3) {
+			printf("%10s : invalid input: too few digits\n", arr[i])
+			continue
+		}
+
+		if (len % 2 == 0) {
+			printf("%10s : invalid input: even number of digits\n", arr[i])
+			continue
+		}
+
+		printf("%10s : %s\n", arr[i], substr(num, len/2, 3))
+	}
+}

Task/Middle-three-digits/Action-/middle-three-digits.action

@@ -0,0 +1,45 @@
+INCLUDE "H6:REALMATH.ACT"
+INCLUDE "D2:PRINTF.ACT" ;from the Action! Tool Kit
+
+PROC MiddleThreeDigits(REAL POINTER n CHAR ARRAY res)
+  REAL r
+  CHAR ARRAY s(15)
+  BYTE i
+
+  RealAbs(n,r)
+  StrR(r,s)
+  i=s(0)
+  IF i<3 OR (i&1)=0 THEN
+    res(0)=0
+  ELSE
+    i==RSH 1
+    SCopyS(res,s,i,i+2)
+  FI
+RETURN
+
+PROC Test(CHAR ARRAY s)
+  REAL n
+  CHAR ARRAY res(4)
+
+  ValR(s,n)
+  MiddleThreeDigits(n,res)
+  IF res(0) THEN
+    PrintF("%9S -> %S%E",s,res)
+  ELSE
+    PrintF("%9S -> error!%E",s)
+  FI
+RETURN
+
+PROC Main()
+  Put(125) PutE() ;clear the screen
+
+  Test("123")     Test("12345")
+  Test("1234567") Test("987654321")
+  Test("10001")   Test("-10001")
+  Test("-123")    Test("-100")
+  Test("100")     Test("-12345")
+  Test("1")       Test("2")
+  Test("-1")      Test("-10")
+  Test("2002")    Test("-2002")
+  Test("0")
+RETURN

Task/Middle-three-digits/Ada/middle-three-digits.ada

@@ -0,0 +1,43 @@
+with Ada.Text_IO;
+
+procedure Middle_Three_Digits is
+
+   Impossible: exception;
+
+   function Middle_String(I: Integer; Middle_Size: Positive) return String is
+      S: constant String := Integer'Image(I);
+      First: Natural := S'First;
+      Full_Size, Border: Natural;
+   begin
+      while S(First) not in '0' .. '9' loop -- skip leading blanks and minus
+         First := First + 1;
+      end loop;
+      Full_Size := S'Last-First+1;
+      if (Full_Size < Middle_Size) or (Full_Size mod 2 = 0) then
+         raise Impossible;
+      else
+         Border := (Full_Size - Middle_Size)/2;
+         return S(First+Border .. First+Border+Middle_Size-1);
+      end if;
+   end Middle_String;
+
+   Inputs: array(Positive range <>) of Integer :=
+     (123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345,
+      1, 2, -1, -10, 2002, -2002, 0);
+   Error_Message: constant String := "number of digits must be >= 3 and odd";
+
+   package IIO is new Ada.Text_IO.Integer_IO(Integer);
+
+begin
+   for I in Inputs'Range loop
+      IIO.Put(Inputs(I), Width => 9);
+      Ada.Text_IO.Put(": ");
+      begin
+         Ada.Text_IO.Put(Middle_String(Inputs(I), 3));
+      exception
+         when Impossible => Ada.Text_IO.Put("****" & Error_Message & "****");
+      end;
+      Ada.Text_IO.New_Line;
+   end loop;
+
+end Middle_Three_Digits;

Task/Middle-three-digits/Aime/middle-three-digits.aime

@@ -0,0 +1,41 @@
+void
+m3(integer i)
+{
+    text s;
+
+    s = itoa(i);
+    if (s[0] == '-') {
+        s = delete(s, 0);
+    }
+
+    if (~s < 3) {
+        v_integer(i);
+        v_text(" has not enough digits\n");
+    } elif (~s & 1) {
+        o_form("/w9/: ~\n", i, cut(s, ~s - 3 >> 1, 3));
+    } else {
+        v_integer(i);
+        v_text(" has an even number of digits\n");
+    }
+}
+
+void
+middle_3(...)
+{
+    integer i;
+
+    i = 0;
+    while (i < count()) {
+        m3($i);
+        i += 1;
+    }
+}
+
+integer
+main(void)
+{
+    middle_3(123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100,
+             -12345, 1, 2, -1, -10, 2002, -2002, 0);
+
+    return 0;
+}

Task/Middle-three-digits/AppleScript/middle-three-digits-1.applescript

@@ -0,0 +1,35 @@
+on middle3Digits(n)
+    try
+        n as number -- Errors if n isn't a number or coercible thereto.
+        set s to n as text -- Keep for the ouput string.
+        if (n mod 1 is not 0) then error (s & " isn't an integer value.")
+        if (n < 0) then set n to -n
+        if (n < 100) then error (s & " has fewer than three digits.")
+        -- Coercing large numbers to text may result in E notation, so extract the digit values individually.
+        set theDigits to {}
+        repeat until (n = 0)
+            set beginning of theDigits to n mod 10 as integer
+            set n to n div 10
+        end repeat
+        set c to (count theDigits)
+        if (c mod 2 is 0) then error (s & " has an even number of digits.")
+    on error errMsg
+        return "middle3Digits handler got an error: " & errMsg
+    end try
+    set i to (c - 3) div 2 + 1
+    set {x, y, z} to items i thru (i + 2) of theDigits
+
+    return "The middle three digits of " & s & " are " & ((x as text) & y & z & ".")
+end middle3Digits
+
+-- Test code:
+set testNumbers to {123, 12345, 1234567, "987654321", "987654321" as number, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0}
+set output to {}
+repeat with thisNumber in testNumbers
+    set end of output to middle3Digits(thisNumber)
+end repeat
+set astid to AppleScript's text item delimiters
+set AppleScript's text item delimiters to linefeed
+set output to output as text
+set AppleScript's text item delimiters to astid
+return output

Task/Middle-three-digits/AppleScript/middle-three-digits-2.applescript

@@ -0,0 +1,18 @@
+"The middle three digits of 123 are 123.
+The middle three digits of 12345 are 234.
+The middle three digits of 1234567 are 345.
+The middle three digits of 987654321 are 654.
+The middle three digits of 9.87654321E+8 are 654.
+The middle three digits of 10001 are 000.
+The middle three digits of -10001 are 000.
+The middle three digits of -123 are 123.
+The middle three digits of -100 are 100.
+The middle three digits of 100 are 100.
+The middle three digits of -12345 are 234.
+middle3Digits handler got an error: 1 has fewer than three digits.
+middle3Digits handler got an error: 2 has fewer than three digits.
+middle3Digits handler got an error: -1 has fewer than three digits.
+middle3Digits handler got an error: -10 has fewer than three digits.
+middle3Digits handler got an error: 2002 has an even number of digits.
+middle3Digits handler got an error: -2002 has an even number of digits.
+middle3Digits handler got an error: 0 has fewer than three digits."

Task/Middle-three-digits/AppleScript/middle-three-digits-3.applescript

@@ -0,0 +1,291 @@
+-------------------- MID THREE DIGITS ---------------------
+
+-- mid3digits :: Int -> Either String String
+on mid3digits(n)
+    -- Either a message explaining why
+    -- no "mid 3 digits" are defined for n,
+    -- or the mid 3 digits themselves.
+
+    set m to abs(n)
+    if 100 > m then
+        |Left|("Less than 3 digits")
+
+    else if maxBound(1) < m then
+        |Left|("Out of AppleScript integer range")
+
+    else
+        set s to m as string
+        set intDigits to length of s
+
+        if even(intDigits) then
+            |Left|("Even digit count")
+        else
+            |Right|((items 1 thru 3 of ¬
+                items (1 + ((intDigits - 3) div 2)) thru -1 of s) as string)
+        end if
+    end if
+end mid3digits
+
+
+-------------------------- TEST ---------------------------
+on run
+    set ints to map(readInt, splitOn(", ", ¬
+        "123, 12345, 1234567, 987654321, 10001, -10001, " & ¬
+        "-123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0"))
+
+
+    script showResult
+        on |λ|(x)
+            either(my bracketed, my str, x)
+        end |λ|
+    end script
+
+    fTable("Mid three digits:", str, showResult, mid3digits, ints)
+end run
+
+
+------------------------ GENERICS -------------------------
+
+-- Left :: a -> Either a b
+on |Left|(x)
+    {type:"Either", |Left|:x, |Right|:missing value}
+end |Left|
+
+
+-- Right :: b -> Either a b
+on |Right|(x)
+    {type:"Either", |Left|:missing value, |Right|:x}
+end |Right|
+
+
+-- abs :: Num -> Num
+on abs(x)
+    -- Absolute value.
+    if 0 > x then
+        -x
+    else
+        x
+    end if
+end abs
+
+
+-- even :: Int -> Bool
+on even(x)
+    0 = x mod 2
+end even
+
+
+-- maxBound :: a -> a
+on maxBound(x)
+    set c to class of x
+    if text is c then
+        character id 65535
+    else if integer is c then
+        (2 ^ 29 - 1)
+    else if real is c then
+        1.797693E+308
+    else if boolean is c then
+        true
+    end if
+end maxBound
+
+
+-------------------- GENERICS FOR TEST AND DISPLAY ---------------------
+
+-- bracketed :: String -> String
+on bracketed(s)
+    "(" & s & ")"
+end bracketed
+
+
+-- compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
+on compose(f, g)
+    script
+        property mf : mReturn(f)
+        property mg : mReturn(g)
+        on |λ|(x)
+            mf's |λ|(mg's |λ|(x))
+        end |λ|
+    end script
+end compose
+
+
+-- either :: (a -> c) -> (b -> c) -> Either a b -> c
+on either(lf, rf, e)
+    if missing value is |Left| of e then
+        tell mReturn(rf) to |λ|(|Right| of e)
+    else
+        tell mReturn(lf) to |λ|(|Left| of e)
+    end if
+end either
+
+
+-- foldl :: (a -> b -> a) -> a -> [b] -> a
+on foldl(f, startValue, xs)
+    tell mReturn(f)
+        set v to startValue
+        set lng to length of xs
+        repeat with i from 1 to lng
+            set v to |λ|(v, item i of xs, i, xs)
+        end repeat
+        return v
+    end tell
+end foldl
+
+
+-- fTable :: String -> (a -> String) -> (b -> String) -> (a -> b) -> [a] -> String
+on fTable(s, xShow, fxShow, f, xs)
+    set ys to map(xShow, xs)
+    set w to maximum(map(my |length|, ys))
+    script arrowed
+        on |λ|(a, b)
+            justifyRight(w, space, a) & " -> " & b
+        end |λ|
+    end script
+    s & linefeed & unlines(zipWith(arrowed, ¬
+        ys, map(compose(fxShow, f), xs)))
+end fTable
+
+
+-- justifyRight :: Int -> Char -> String -> String
+on justifyRight(n, cFiller, strText)
+    if n > length of strText then
+        text -n thru -1 of ((replicate(n, cFiller) as text) & strText)
+    else
+        strText
+    end if
+end justifyRight
+
+
+-- length :: [a] -> Int
+on |length|(xs)
+    set c to class of xs
+    if list is c or string is c then
+        length of xs
+    else
+        (2 ^ 29 - 1) -- (maxInt - simple proxy for non-finite)
+    end if
+end |length|
+
+
+-- map :: (a -> b) -> [a] -> [b]
+on map(f, xs)
+    -- The list obtained by applying f
+    -- to each element of xs.
+    tell mReturn(f)
+        set lng to length of xs
+        set lst to {}
+        repeat with i from 1 to lng
+            set end of lst to |λ|(item i of xs, i, xs)
+        end repeat
+        return lst
+    end tell
+end map
+
+
+-- maximum :: Ord a => [a] -> a
+on maximum(xs)
+    script
+        on |λ|(a, b)
+            if a is missing value or b > a then
+                b
+            else
+                a
+            end if
+        end |λ|
+    end script
+
+    foldl(result, missing value, xs)
+end maximum
+
+
+-- min :: Ord a => a -> a -> a
+on min(x, y)
+    if y < x then
+        y
+    else
+        x
+    end if
+end min
+
+
+-- mReturn :: First-class m => (a -> b) -> m (a -> b)
+on mReturn(f)
+    -- 2nd class handler function lifted into 1st class script wrapper.
+    if script is class of f then
+        f
+    else
+        script
+            property |λ| : f
+        end script
+    end if
+end mReturn
+
+
+-- readInt :: String -> Int
+on readInt(s)
+    s as integer
+end readInt
+
+
+-- Egyptian multiplication - progressively doubling a list, appending
+-- stages of doubling to an accumulator where needed for binary
+-- assembly of a target length
+-- replicate :: Int -> a -> [a]
+on replicate(n, a)
+    set out to {}
+    if 1 > n then return out
+    set dbl to {a}
+
+    repeat while (1 < n)
+        if 0 < (n mod 2) then set out to out & dbl
+        set n to (n div 2)
+        set dbl to (dbl & dbl)
+    end repeat
+    return out & dbl
+end replicate
+
+
+-- splitOn :: String -> String -> [String]
+on splitOn(pat, src)
+    set {dlm, my text item delimiters} to ¬
+        {my text item delimiters, pat}
+    set xs to text items of src
+    set my text item delimiters to dlm
+    return xs
+end splitOn
+
+
+-- str :: a -> String
+on str(x)
+    x as string
+end str
+
+
+-- unlines :: [String] -> String
+on unlines(xs)
+    -- A single string formed by the intercalation
+    -- of a list of strings with the newline character.
+    set {dlm, my text item delimiters} to ¬
+        {my text item delimiters, linefeed}
+    set s to xs as text
+    set my text item delimiters to dlm
+    s
+end unlines
+
+
+-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+on zipWith(f, xs, ys)
+    set lng to min(length of xs, length of ys)
+    set lst to {}
+    if 1 > lng then
+        return {}
+    else
+        tell mReturn(f)
+            repeat with i from 1 to lng
+                set end of lst to |λ|(item i of xs, item i of ys)
+            end repeat
+            return lst
+        end tell
+    end if
+end zipWith

Task/Middle-three-digits/Applesoft-BASIC/middle-three-digits.basic

@@ -0,0 +1,22 @@
+100 DEF FN L(N) = LEN(STR$(INT(ABS(N))))
+110 DEF FN N(N) = VAL(MID$(STR$(INT(ABS(N))),(FN L(N)-1)/2,3))
+120 DEF FN EVEN(N) = INT(N/2) = N/2
+130 FOR I = 1 TO 20
+140     READ N
+150     PRINT N":",
+160     GOSUB 100"MIDDLE THREE DIGITS
+170     PRINT R$
+180 NEXT
+190 END
+200 R$ = ""
+210 IF FN EVEN(FN L(N)) THEN R$ = "?EVEN,"
+220 IF FN L(N) < 3 THEN R$ = R$ + "ONLY " + STR$(FN L(N)) + " DIGIT" + MID$("S",FN L(N) - 1, 1)
+230 IF RIGHT$(R$, 1) = "," THEN R$ = LEFT$(R$, LEN(R$) - 1) : RETURN
+240 IF LEFT$(R$, 1) = "?" THEN RETURN
+250 IF R$ <> "" THEN R$ = "?" + R$ : RETURN
+260 R$ = STR$(FN N(N))
+270 IF LEN(R$) = 1 THEN R$ = "00" + R$
+280 IF LEN(R$) = 2 THEN R$ = "0" + R$
+290 RETURN
+300 DATA123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345
+310 DATA1,2,-1,-10,2002,-2002,0

Task/Middle-three-digits/Arturo/middle-three-digits.arturo

@@ -0,0 +1,17 @@
+middleThree: function [num][
+    n: to :string abs num
+    if 3 > size n -> return "Number must have at least three digits"
+    if even? size n -> return "Number must have an odd number of digits"
+
+    middle: ((size n)/2)- 1
+    return slice n middle middle+2
+]
+
+samples: @[
+    123, 12345, 1234567, 987654321, 10001, neg 10001, neg 123, neg 100, 100, neg 12345,
+    1, 2, neg 1, neg 10, 2002, neg 2002, 0
+]
+
+loop samples 's [
+    print [pad to :string s 10 ":" middleThree s]
+]

Task/Middle-three-digits/AutoHotkey/middle-three-digits.ahk

@@ -0,0 +1,13 @@
+Numbers:="123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,1,2,-1,-10,2002,-2002,0"
+Loop, parse, Numbers, `,
+{
+	if A_LoopField is not number
+		log := log . A_LoopField . "`t: Not a valid number`n"
+	else if((d:=StrLen(n:=RegExReplace(A_LoopField,"\D")))<3)
+		log := log . A_LoopField . "`t: Too short`n"
+	else if(!Mod(d,2))
+		log := log . A_LoopField . "`t: Not an odd number of digits`n"
+	else
+		log := log . A_LoopField . "`t: " . SubStr(n,((d-3)//2)+1,3) . "`n"
+}
+MsgBox % log

Task/Middle-three-digits/BBC-BASIC/middle-three-digits.basic

@@ -0,0 +1,21 @@
+REM >midthree
+FOR i% = 1 TO 17
+  READ test%
+  PRINT test%; " -> "; FN_middle_three(test%)
+NEXT
+END
+:
+DATA 123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345
+DATA 1, 2, -1, -10, 2002, -2002, 0
+:
+DEF FN_middle_three(n%)
+LOCAL n$
+n$ = STR$ ABS n%
+CASE TRUE OF
+WHEN LEN n$ < 3
+  = "Not enough digits"
+WHEN LEN n$ MOD 2 = 0
+  = "Even number of digits"
+OTHERWISE
+  = MID$(n$, LEN n$ / 2, 3)
+ENDCASE

Task/Middle-three-digits/Batch-File/middle-three-digits.bat

@@ -0,0 +1,46 @@
+@echo off
+setlocal enabledelayedexpansion
+
+	%== Initialization ==%
+set "numbers=123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0"
+
+	%== The Main Thing ==%
+for %%N in (%numbers%) do (
+	call :middle3 %%N
+)
+echo.
+pause
+exit /b 0
+	%==/The Main Thing ==%
+
+	%== The Procedure ==%
+:middle3
+
+	set str=%1
+	%== Making sure that str is positive ==%
+	if !str! lss 0 set /a str*=-1
+
+	%== Alternative for finding the string length ==%
+	%== But this has a limit of 1000 characters ==%
+	set leng=0&if not "!str!"=="" for /l %%. in (0,1,1000) do if not "!str:~%%.,1!"=="" set /a leng+=1
+
+	if !leng! lss 3 (
+		echo.%~1:		[ERROR] Input too small.
+		goto :EOF
+	)
+
+	set /a "test2=leng %% 2,trimmer=(leng - 3) / 2"
+
+	if !test2! equ 0 (
+		echo.%~1:		[ERROR] Even number of digits.
+		goto :EOF
+	)
+
+	%== Passed the tests. Now, really find the middle 3 digits... ==%
+	if !trimmer! equ 0 (
+		echo.%~1:		!str!
+	) else (
+		echo.%~1:		!str:~%trimmer%,-%trimmer%!
+	)
+	goto :EOF
+	%==/The Procedure ==%

Task/Middle-three-digits/Befunge/middle-three-digits.bf

@@ -0,0 +1,8 @@
+>&>:0`2*1-*0>v
+v+*86%+55:p00<
+>\55+/:00g1+\|
+v3_v#*%2\`2::<
+->@>0".rorrE"v
+2^,+55_,#!>#:<
+>/>\#<$#-:#1_v
+>_@#<,+55,,,$<

Task/Middle-three-digits/Bracmat/middle-three-digits.bracmat

@@ -0,0 +1,15 @@
+( ( middle3
+  =   x p
+    .     @(!arg:? [?p:? [(1/2*!p+-3/2) %?x [(1/2*!p+3/2) ?)
+        & !x
+      |   !arg
+          ( !p:<3&"is too small"
+          | "has even number of digits"
+          )
+  )
+&     123 12345 1234567 987654321 10001 -10001 -123 -100 100
+      -12345 1 2 -1 -10 2002 -2002 0
+  : ?L
+& whl'(!L:%?e ?L&out$(middle3$!e))
+&
+);

Task/Middle-three-digits/Burlesque/middle-three-digits.blq

@@ -0,0 +1,7 @@
+blsq ) {123 12345 1234567 987654321 -10001 -123}{XX{~-}{L[3.>}w!m]\[}m[uN
+123
+234
+345
+654
+000
+123

Task/Middle-three-digits/C++/middle-three-digits.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+
+std::string middleThreeDigits(int n)
+{
+    auto number = std::to_string(std::abs(n));
+    auto length = number.size();
+
+    if (length < 3) {
+        return "less than three digits";
+    } else if (length % 2 == 0) {
+        return "even number of digits";
+    } else {
+        return number.substr(length / 2 - 1, 3);
+    }
+}
+
+int main()
+{
+    auto values {123, 12345, 1234567, 987654321, 10001,
+                 -10001, -123, -100, 100, -12345,
+                 1, 2, -1, -10, 2002, -2002, 0};
+
+    for (auto&& v : values) {
+        std::cout << "middleThreeDigits(" << v << "): " <<
+                     middleThreeDigits(v) << "\n";
+    }
+}

Task/Middle-three-digits/C-sharp/middle-three-digits.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace RosettaCode
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            string text = Math.Abs(int.Parse(Console.ReadLine())).ToString();
+            Console.WriteLine(text.Length < 2 || text.Length % 2 == 0 ? "Error" : text.Substring((text.Length - 3) / 2, 3));
+        }
+    }
+}

Task/Middle-three-digits/C/middle-three-digits-1.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// we return a static buffer; caller wants it, caller copies it
+char * mid3(int n)
+{
+	static char buf[32];
+	int l;
+	sprintf(buf, "%d", n > 0 ? n : -n);
+	l = strlen(buf);
+	if (l < 3 || !(l & 1)) return 0;
+	l = l / 2 - 1;
+	buf[l + 3] = 0;
+	return buf + l;
+}
+
+int main(void)
+{
+	int x[] = {123, 12345, 1234567, 987654321, 10001, -10001,
+		-123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0,
+		1234567890};
+
+	int i;
+	char *m;
+	for (i = 0; i < sizeof(x)/sizeof(x[0]); i++) {
+		if (!(m = mid3(x[i])))
+			m = "error";
+		printf("%d: %s\n", x[i], m);
+	}
+	return 0;
+}

Task/Middle-three-digits/C/middle-three-digits-2.c

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void midThree(char arg[])
+{
+    char output[4];
+    int midPoint;
+    arg[0]=='-'?midPoint = ((strlen(arg) + 1) / 2):midPoint = ((strlen(arg) + 1) / 2) - 1;
+
+    if(strlen(arg) < 3)
+        {
+            printf("Error, %d is too short.\n",atoi(arg));
+            return ;
+        }
+        else if(strlen(arg)  == 4 || strlen(arg) == 3)
+        {
+            printf("Error, %d has %d digits, no 3 middle digits.\n",atoi(arg),arg[0]=='-'?strlen(arg)-1:strlen(arg));
+            return ;
+        }
+    else{
+    for(int i=0; i<3; i++)
+    {
+        output[i] = arg[(midPoint-1) + i];
+    }
+    output[3] = '\0';
+    printf("The middle three digits of %s are %s.\n",arg,output);
+}}
+
+int main(int argc, char * argv[])
+{
+    char input[50];
+    int x[] = {123, 12345, 1234567, 987654321, 10001, -10001,
+		-123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0,
+		1234567890},i;
+		
+    if(argc < 2)
+    {
+        printf("Usage: %s <integer>\n",argv[0]);
+        printf("Examples with preloaded data shown below :\n");
+
+        for(i=0;i<18;i++)
+        {
+	        midThree(itoa(x[i],argv[0],10));
+	     }
+        return 1;
+    }
+    else
+    {
+        sprintf(input,"%d",atoi(argv[1]));
+            midThree(argv[1]);
+            return 0;
+
+
+    }
+}

Task/Middle-three-digits/CLU/middle-three-digits.clu

@@ -0,0 +1,24 @@
+middle_three_digits = proc (n: int) returns (string)
+                      signals (too_small, even_length)
+    s: string := int$unparse(int$abs(n))
+    if string$size(s) < 3 then signal too_small end
+    if string$size(s) // 2 = 0 then signal even_length end
+    return(string$substr(s, string$size(s)/2, 3))
+end middle_three_digits
+
+start_up = proc ()
+    po: stream := stream$primary_output()
+    tests: sequence[int] := sequence[int]$
+        [123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,
+         1,2,-1,-10,2002,-2002,0]
+
+    for test: int in sequence[int]$elements(tests) do
+        stream$putright(po, int$unparse(test) || ": ", 11)
+
+        stream$putl(po, middle_three_digits(test))
+        except
+            when too_small: stream$putl(po, "Too small")
+            when even_length: stream$putl(po, "Even length")
+        end
+    end
+end start_up

Task/Middle-three-digits/COBOL/middle-three-digits-1.cobol

@@ -0,0 +1,91 @@
+identification division.
+program-id. middle3.
+environment division.
+data division.
+working-storage section.
+01  num                 pic 9(9).
+    88 num-too-small    values are -99 thru 99.
+01  num-disp            pic ---------9.
+
+01  div                 pic 9(9).
+01  mod                 pic 9(9).
+01  mod-disp            pic 9(3).
+
+01  digit-counter       pic 999.
+01  digit-div           pic 9(9).
+    88  no-more-digits  value 0.
+01  digit-mod           pic 9(9).
+    88  is-even         value 0.
+
+01  multiplier          pic 9(9).
+
+01  value-items.
+    05  filler  pic s9(9) value 123.
+    05  filler  pic s9(9) value 12345.
+    05  filler  pic s9(9) value 1234567.
+    05  filler  pic s9(9) value 987654321.
+    05  filler  pic s9(9) value 10001.
+    05  filler  pic s9(9) value -10001.
+    05  filler  pic s9(9) value -123.
+    05  filler  pic s9(9) value -100.
+    05  filler  pic s9(9) value 100.
+    05  filler  pic s9(9) value -12345.
+    05  filler  pic s9(9) value 1.
+    05  filler  pic s9(9) value 2.
+    05  filler  pic s9(9) value -1.
+    05  filler  pic s9(9) value -10.
+    05  filler  pic s9(9) value 2002.
+    05  filler  pic s9(9) value -2002.
+    05  filler  pic s9(9) value 0.
+
+01  value-array redefines value-items.
+    05  items   pic s9(9)  occurs 17 times indexed by item.
+
+01  result  pic x(20).
+
+procedure division.
+10-main.
+    perform with test after varying item from 1 by 1 until items(item) = 0
+        move items(item) to num
+        move items(item) to num-disp
+        perform 20-check
+        display num-disp " --> " result
+    end-perform.
+    stop run.
+
+20-check.
+    if num-too-small
+        move "Number too small" to result
+        exit paragraph
+    end-if.
+
+    perform 30-count-digits.
+    divide digit-counter by 2 giving digit-div remainder digit-mod.
+    if is-even
+        move "Even number of digits" to result
+        exit paragraph
+    end-if.
+
+    *> if digit-counter is 5, mul by 10
+    *> if digit-counter is 7, mul by 100
+    *> if digit-counter is 9, mul by 1000
+
+    if digit-counter > 3
+        compute multiplier rounded = 10 ** (((digit-counter - 5) / 2) + 1)
+        divide num by multiplier giving num
+        divide num by 1000 giving div remainder mod
+        move mod to mod-disp
+    else
+        move num to mod-disp
+    end-if.
+    move mod-disp to result.
+    exit paragraph.
+
+30-count-digits.
+    move zeroes to digit-counter.
+    move num to digit-div.
+    perform with test before until no-more-digits
+        divide digit-div by 10 giving digit-div remainder digit-mod
+        add 1 to digit-counter
+    end-perform.
+    exit paragraph.

Task/Middle-three-digits/COBOL/middle-three-digits-2.cobol

@@ -0,0 +1,71 @@
+identification division.
+program-id. middle3.
+environment division.
+data division.
+working-storage section.
+01  value-items.
+        05  filler  pic s9(9) value 123.
+        05  filler  pic s9(9) value 12345.
+        05  filler  pic s9(9) value 1234567.
+        05  filler  pic s9(9) value 987654321.
+        05  filler  pic s9(9) value 10001.
+        05  filler  pic s9(9) value -10001.
+        05  filler  pic s9(9) value -123.
+        05  filler  pic s9(9) value -100.
+        05  filler  pic s9(9) value 100.
+        05  filler  pic s9(9) value -12345.
+        05  filler  pic s9(9) value 1.
+        05  filler  pic s9(9) value 2.
+        05  filler  pic s9(9) value -1.
+        05  filler  pic s9(9) value -10.
+        05  filler  pic s9(9) value 2002.
+        05  filler  pic s9(9) value -2002.
+        05  filler  pic s9(9) value 0.
+
+01 value-array redefines value-items.
+        05  items   pic s9(9)  occurs 17 times indexed by item.
+
+01 num      pic 9(9).
+01 num-disp pic ---------9.
+01 num2     pic 9(9).
+
+01 power    pic 9.
+01 power10  pic 9(16).
+
+01 three-digits pic 999.
+
+01 result   pic X(20).
+
+01 flag     pic 9.
+    88 done value 1.
+
+procedure division.
+01-setup.
+    perform 02-outer with test after varying item from 1 by 1 until items(item) = 0.
+    stop run.
+
+02-outer.
+    move items(item) to num.
+    move items(item) to num-disp.
+    if num less than 100
+        move "too small" to result
+    else
+        perform 03-inner with test after varying power from 9 by -1 until power = 1 or done
+    end-if.
+    display num-disp " --> " result.
+    exit paragraph.
+
+03-inner.
+    move 0 to flag.
+    compute power10 = 10 ** power.
+    if num >= power10
+        move 1 to flag
+        if function mod(power,2) = 1
+            move "even number digits" to result
+        else
+            move num to num2
+            compute num2 = num2 / ( 10 ** (( power / 2 ) - 1 ))
+            move function mod(num2,1000) to three-digits
+            move three-digits to result
+        end-if
+    end-if.

Task/Middle-three-digits/Clojure/middle-three-digits.clj

@@ -0,0 +1,14 @@
+(defn middle3
+  [v]
+  (let [digit-str (str (Math/abs v))
+        len (count digit-str)]
+    (cond
+      (< len 3) :too-short
+      (even? len) :even-digit-count
+      :else (let [half (/ len 2)]
+              (subs digit-str (- half 1) (+ half 2))))))
+
+(clojure.pprint/print-table
+ (for [i [123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345
+          1 2 -1 -10 2002 -2002 0]]
+   {:i i :middle-3 (middle3 i)}))

Task/Middle-three-digits/Common-Lisp/middle-three-digits-1.lisp

@@ -0,0 +1,12 @@
+(defun mid3 (n)
+  (let ((a (abs n))
+        (hmd)) ; how many digits
+    (labels ((give (fmt &optional x y) (return-from mid3 (format nil fmt x y)))
+             (need (x) (give "Need ~a digits, not ~d." x hmd))
+             (nbr (n) (give "~3,'0d" n)))
+      (when (zerop n) (give "Zero is 1 digit"))
+      (setq hmd (truncate (1+ (log a 10))))
+      (cond ((< hmd 3) (need "3+"))
+            ((= hmd 3) (nbr a))
+            ((evenp hmd) (need "odd number of"))
+            (t (nbr (mod (truncate a (expt 10 (/ (- hmd 3) 2))) 1000)))))))

Task/Middle-three-digits/Common-Lisp/middle-three-digits-2.lisp

@@ -0,0 +1,4 @@
+(loop as n in '(123 12345 1234567 987654321
+                    10001 -10001 -123 -100 100 -12345
+                    1 2 -1 -10 2002 -2002 0)
+      do (format t "~d:~12t~a~%" n (mid3 n)))

Task/Middle-three-digits/Common-Lisp/middle-three-digits-3.lisp

@@ -0,0 +1,17 @@
+(defun mid3 (i)
+  (let ((ch-vec (coerce (format nil "~A" (abs i)) 'vector)))
+    (when (evenp (length ch-vec))
+      (return-from mid3
+        (format nil "Error: The number representation must have an odd ~
+                     number of digits.")))
+
+    (when (and (< i 100)
+               (> i -100))
+      (return-from mid3
+        (format nil "Error: Must be >= 100 or <= -100.")))
+    (let ((half (/ (1- (length ch-vec)) 2)))
+      (return-from mid3 (format nil "~A~A~A"
+                                   (elt ch-vec (1- half))
+                                   (elt ch-vec half)
+                                   (elt ch-vec (1+ half))))
+      )))

Task/Middle-three-digits/Common-Lisp/middle-three-digits-4.lisp

@@ -0,0 +1,31 @@
+(defun test-mid3 ()
+  (let ((test-lst (list 123
+                        12345
+                        1234567
+                        987654321
+                        10001
+                        -10001
+                        -123
+                        -100
+                        100
+                        -12345
+                        1
+                        2
+                        -1
+                        -10
+                        2002
+                        -2002
+                        0
+                        )))
+    (labels
+        ((run-tests (lst)
+           (cond ((null lst)
+                  nil)
+
+                 (t
+                  (format t "~A ~15T ~A~%" (first lst) (mid3 (first lst)))
+                  (run-tests (rest lst))))))
+
+      (run-tests test-lst)))
+  (values)
+  )

Task/Middle-three-digits/D/middle-three-digits-1.d

@@ -0,0 +1,21 @@
+import std.stdio, std.traits, std.conv;
+
+string middleThreeDigits(T)(in T n) pure nothrow if (isIntegral!T) {
+    auto s = n < 0 ? n.text[1 .. $] : n.text;
+    auto len = s.length;
+    if (len < 3 || len % 2 == 0)
+        return "Need odd and >= 3 digits";
+    auto mid = len / 2;
+    return s[mid - 1 .. mid + 2];
+}
+
+void main() {
+    immutable passing = [123, 12345, 1234567, 987654321, 10001, -10001,
+            -123, -100, 100, -12345, long.min, long.max];
+    foreach (immutable n; passing)
+        writefln("middleThreeDigits(%s): %s", n, middleThreeDigits(n));
+
+    immutable failing = [1, 2, -1, -10, 2002, -2002, 0,int.min,int.max];
+    foreach (immutable n; failing)
+        writefln("middleThreeDigits(%s): %s", n, middleThreeDigits(n));
+}

Task/Middle-three-digits/D/middle-three-digits-2.d

@@ -0,0 +1,87 @@
+import std.stdio, std.traits, std.math, std.variant;
+
+/// Returns a string with the error, or the three digits.
+Algebraic!(string, char[3]) middleThreeDigits(T)(in T n)
+if (isIntegral!T) {
+    // Awkward code to face abs(T.min) when T is signed.
+    ulong ln;
+    static if (isSigned!T) {
+        if (n >= 0) {
+            ln = n;
+        } else {
+            if (n == T.min) {
+                ln = -(n + 1);
+                ln++;
+            } else {
+                ln = -n;
+            }
+        }
+    } else {
+        ln = n;
+    }
+
+    if (ln < 100)
+        return typeof(return)("n is too short.");
+    immutable uint digits = 1 + cast(uint)log10(ln);
+    if (digits % 2 == 0)
+        return typeof(return)("n must have an odd number of digits.");
+
+    // From the Reddit answer by "millstone".
+    int drop = (digits - 3) / 2;
+    while (drop-- > 0)
+        ln /= 10;
+
+    char[3] result = void;
+    result[2] = ln % 10 + '0';
+    ln /= 10;
+    result[1] = ln % 10 + '0';
+    ln /= 10;
+    result[0] = ln % 10 + '0';
+    return typeof(return)(result);
+}
+
+void main() {
+    immutable passing = [123, 12345, 1234567, 987654321, 10001,
+                         -10001, -123, -100, 100, -12345, -8765432];
+    foreach (n; passing) {
+        auto mtd = middleThreeDigits(n);
+        // A string result means it didn't pass.
+        assert(!mtd.peek!string);
+        writefln("middleThreeDigits(%d): %s", n, mtd);
+    }
+    writeln();
+
+    immutable failing = [1, 2, -1, -10, 2002, -2002, 0,
+                         15, int.min, int.max];
+    foreach (n; failing) {
+        auto mtd = middleThreeDigits(n);
+        assert(mtd.peek!string);
+        writefln("middleThreeDigits(%d): %s", n, mtd);
+    }
+    writeln();
+
+    immutable long[] passingL = [123, 12345, 1234567, 987654321, 10001,
+                                 -10001, -123, -100, 100, -12345,
+                                 -8765432, long.min, long.max];
+    foreach (n; passingL) {
+        auto mtd = middleThreeDigits(n);
+        assert(!mtd.peek!string);
+        writefln("middleThreeDigits(%d): %s", n, mtd);
+    }
+    writeln();
+
+    immutable long[] failingL = [1, 2, -1, -10, 2002, -2002, 0, 15];
+    foreach (n; failingL) {
+        auto mtd = middleThreeDigits(n);
+        assert(mtd.peek!string);
+        writefln("middleThreeDigits(%d): %s", n, mtd);
+    }
+    writeln();
+
+    {
+        immutable n = short.min;
+        auto mtd = middleThreeDigits(n);
+        assert(!mtd.peek!string);
+        writefln("middleThreeDigits(cast(short)%d): %s", n, mtd);
+    }
+}

Task/Middle-three-digits/DCL/middle-three-digits.dcl

@@ -0,0 +1,15 @@
+$ list = "123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,1,2,-1,-10,2002,-2002,0"
+$ i = 0
+$ loop:
+$  number = f$element( i, ",", list )
+$  if number .eqs. "," then $ exit
+$  abs_number = number - "-"
+$  len = f$length( abs_number )
+$  if len .lt. 3 .or. .not. len
+$  then
+$   write sys$output f$fao( "!9SL: ", f$integer( number )), "has no middle three"
+$  else
+$   write sys$output f$fao( "!9SL: ", f$integer( number )), f$extract( ( len - 3 ) / 2, 3, abs_number )
+$  endif
+$  i = i + 1
+$  goto loop

Task/Middle-three-digits/Dart/middle-three-digits.dart

@@ -0,0 +1,46 @@
+import'dart:math';
+  int length(int x)
+  {
+    int i,y;
+  for(i=0;;i++)
+  {
+    y=pow(10,i);
+    if(x%y==x)
+      break;
+  }
+    return i;
+  }
+ int middle(int x,int l)
+  {
+ int a=(x/10)-((x%10)/10);
+  int b=a%(pow(10,l-2));
+  int l2=length(b);
+      if(l2==3)
+      {
+        return b;
+      }
+    if(l2!=3)
+      {
+        return middle(b,l2);
+      }
+  return 0;
+  }
+
+
+main()
+{
+  int x=-100,y;
+  if(x<0)
+ x=-x;
+  int l=length(x);
+  if(l.isEven||x<100)
+  {print('error');}
+    if(l==3)
+  {print('$x');}
+
+  if(l.isOdd&& x>100)
+  {
+   y=middle(x,l);
+  print('$y');
+  }
+}

Task/Middle-three-digits/ERRE/middle-three-digits.erre

@@ -0,0 +1,44 @@
+PROGRAM MIDDLE
+
+!$DOUBLE
+
+FUNCTION LUNG(N)
+   LUNG=LEN(STR$(INT(ABS(N))))+1
+END FUNCTION
+
+FUNCTION NCNT(N)
+    NCNT=VAL(MID$(STR$(INT(ABS(N))),(LUNG(N)-1)/2,3))
+END FUNCTION
+
+FUNCTION EVEN(N)
+    EVEN=INT(N/2)=N/2
+END FUNCTION
+
+PROCEDURE NUMBER_EXAM(N->R$)
+    R$=""   LG%=LUNG(N)-2
+    IF EVEN(LG%) THEN R$="?EVEN,"  END IF
+    IF LG%<3 THEN
+             R$=R$+"ONLY"+STR$(LG%)+" DIGIT"
+             IF LG%=1 THEN
+                 R$=R$+"S"
+             END IF
+    END IF
+    IF RIGHT$(R$,1)="," THEN R$=LEFT$(R$,LEN(R$)-1)   EXIT PROCEDURE END IF
+    IF LEFT$(R$,1)="?" THEN EXIT PROCEDURE END IF
+    IF R$<>"" THEN R$="?"+R$   EXIT PROCEDURE END IF
+    R$=STR$(NCNT(N))
+    IF LEFT$(R$,1)=" " THEN R$=MID$(R$,2) END IF
+    IF LEN(R$)=1 THEN R$="00"+R$  END IF
+    IF LEN(R$)=2 THEN R$="0"+R$   END IF
+END PROCEDURE
+
+BEGIN
+    DATA(123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345)
+    DATA(1,2,-1,-10,2002,-2002,0)
+    FOR I%=1 TO 17 DO
+        READ(N)
+        PRINT(N;"  ",)
+        NUMBER_EXAM(N->R$)
+        PRINT(R$)
+    END FOR
+END PROGRAM

Task/Middle-three-digits/EasyLang/middle-three-digits.easy

@@ -0,0 +1,13 @@
+proc midThreeDigits num . result$ .
+   trueNumber$ = abs num
+   if (len trueNumber$ < 3) or (len trueNumber$ mod 2 = 0)
+      result$ = "error"
+   else
+      result$ = substr trueNumber$ ((len trueNumber$ - 3) / 2 + 1) 3
+   .
+.
+numbers[] = [ 123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345 1 2 -1 -10 2002 -2002 0 ]
+for i in numbers[]
+   call midThreeDigits i result$
+   print result$
+.

Task/Middle-three-digits/Eiffel/middle-three-digits.e

@@ -0,0 +1,61 @@
+class
+	APPLICATION
+
+create
+	make
+
+feature
+
+	make
+			-- Test of middle_three_digits.
+		local
+			test_1, test_2: ARRAY [INTEGER]
+		do
+			test_1 := <<123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345>>
+			test_2 := <<1, 2, -1, -10, 2002, -2002, 0>>
+			across
+				test_1 as t
+			loop
+				io.put_string ("The middle three digits of " + t.item.out + " are: %T ")
+				io.put_string (middle_three_digits (t.item) + "%N")
+			end
+			across
+				test_2 as t
+			loop
+				io.put_string ("The middle three digits of " + t.item.out + " are: %T")
+				io.put_string (middle_three_digits (t.item) + "%N")
+			end
+		end
+
+	middle_three_digits (n: INTEGER): STRING
+			-- The middle three digits of 'n'.
+		local
+			k, i: INTEGER
+			in: STRING
+		do
+			create in.make_empty
+			in := n.out
+			if n < 0 then
+				in.prune ('-')
+			end
+			create Result.make_empty
+			if in.count < 3 then
+				io.put_string (" Not enough digits. ")
+			elseif in.count \\ 2 = 0 then
+				io.put_string (" Even number of digits. ")
+			else
+				i := (in.count - 3) // 2
+				from
+					k := i + 1
+				until
+					k > i + 3
+				loop
+					Result.extend (in.at (k))
+					k := k + 1
+				end
+			end
+		ensure
+			length_is_three: Result.count = 3 or Result.count = 0
+		end
+
+end

Task/Middle-three-digits/Elena/middle-three-digits.elena

@@ -0,0 +1,29 @@
+import system'routines;
+import extensions;
+
+middleThreeDigits(int n)
+{
+    string s := n.Absolute.toString();
+    int len := s.Length;
+    if(len<3)
+    {
+        InvalidArgumentException.new:"n must have 3 digits or more".raise()
+    }
+    else if(len.isEven())
+    {
+        InvalidArgumentException.new:"n must have an odd number of digits".raise()
+    };
+
+    int mid := len / 2;
+
+    ^ s.Substring(mid-1,3)
+}
+
+public program()
+{
+    new int[]{123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0}
+        .forEach:(n)
+        {
+            console.printLine("middleThreeDigits(",n,"):",middleThreeDigits(n) | on:(e => e.Message))
+        }
+}

Task/Middle-three-digits/Elixir/middle-three-digits.elixir

@@ -0,0 +1,30 @@
+defmodule Middle do
+  def three(num) do
+    n = num |> abs |> to_string
+
+    case {n,String.length(n) > 2,even?(n)} do
+      {n, true, false} ->
+        cut(n)
+      {_, false, _} ->
+        raise "Number must have at least three digits"
+      {_, _, true} ->
+        raise "Number must have an odd number of digits"
+    end
+  end
+
+  defp even?(n), do: rem(String.length(n),2) == 0
+  defp cut(n), do: String.slice(n,(div(String.length(n),2) - 1),3)
+end
+
+valids = [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345]
+Enum.each(valids, fn n -> :io.format "~10w : ~s~n", [n, Middle.three(n)] end)
+
+errors = [1, 2, -1, -10, 2002, -2002, 0]
+Enum.each(errors, fn n ->
+  :io.format "~10w : ", [n]
+  try do
+    IO.puts Middle.three(n)
+  rescue
+    e -> IO.puts e.message
+  end
+end)

Task/Middle-three-digits/Erlang/middle-three-digits.erl

@@ -0,0 +1,39 @@
+%
+-module(middle_three_digits).
+-export([main/0]).
+
+main() ->
+	digits(123),
+	digits(12345),
+	digits(1234567),
+	digits(987654321),	
+	digits(10001),
+	digits(-10001),
+	digits(-123),	
+	digits(-100),
+	digits(100),
+	digits(-12345),
+	digits(1),
+	digits(2),
+	digits(-1),
+	digits(-10),
+	digits(2002),
+	digits(-2002),
+	digits(0).
+
+digits(N) when N < 0 ->
+	digits(-N);
+digits(N) when (N div 100) =:= 0  ->
+	io:format("too small\n");
+digits(N) ->
+	K=length(integer_to_list(N)),
+	if (K rem 2) =:= 0 ->
+		io:format("even number of digits\n");
+	true ->	
+		loop((K-3) div 2 , N)
+	end.
+
+loop(0, N) ->
+	io:format("~3..0B~n",[N rem 1000]);	
+loop(X,N)  when X>0 ->
+	loop(X-1, N div 10).

Task/Middle-three-digits/FBSL/middle-three-digits.fbsl

@@ -0,0 +1,45 @@
+#APPTYPE CONSOLE
+
+DIM numbers AS STRING = "123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,1,2,-1,-10,2002,-2002,0"
+DIM dict[] = Split(numbers, ",")
+DIM num AS INTEGER
+DIM num2 AS INTEGER
+DIM powered AS INTEGER
+
+FOR DIM i = 0 TO COUNT(dict) - 1
+    num2 = dict[i]
+    num = ABS(num2)
+    IF num < 100 THEN
+        display(num2, "is too small")
+    ELSE
+        FOR DIM j = 9 DOWNTO 1
+            powered = 10 ^ j
+            IF num >= powered THEN
+                IF j MOD 2 = 1 THEN
+                    display(num2, "has even number of digits")
+                ELSE
+                    display(num2, middle3(num, j))
+                END IF
+                EXIT FOR
+            END IF
+        NEXT
+    END IF
+NEXT
+
+PAUSE
+
+FUNCTION display(num, msg)
+    PRINT LPAD(num, 11, " "), " --> ", msg
+END FUNCTION
+
+FUNCTION middle3(n, pwr)
+    DIM power AS INTEGER = (pwr \ 2) - 1
+    DIM m AS INTEGER = n
+    m = m \ (10 ^ power)
+    m = m MOD 1000
+    IF m = 0 THEN
+        RETURN "000"
+    ELSE
+        RETURN m
+    END IF
+END FUNCTION

Task/Middle-three-digits/Factor/middle-three-digits.factor

@@ -0,0 +1,29 @@
+USING: combinators formatting io kernel math math.parser
+sequences ;
+IN: rosetta-code.middle-three-digits
+
+CONSTANT: test-values {
+    123 12345 1234567 987654321 10001 -10001
+    -123 -100 100 -12345 1 2 -1 -10 2002 -2002 0
+}
+
+: (middle-three) ( str -- str' )
+    [ midpoint@ [ 1 - ] [ 2 + ] bi ] [ subseq ] bi ;
+
+: too-short ( -- )
+    "Number must have at least three digits." print ;
+
+: number-even ( -- )
+    "Number must have an odd number of digits." print ;
+
+: middle-three ( n -- )
+    abs number>string {
+        { [ dup length 3 < ] [ drop too-short ] }
+        { [ dup length even? ] [ drop number-even ] }
+        [ (middle-three) print ]
+    } cond ;
+
+: main ( -- )
+    test-values [ dup "%9d : " printf middle-three ] each ;
+
+MAIN: main

Task/Middle-three-digits/Forth/middle-three-digits.fth

@@ -0,0 +1,4 @@
+: middle3          ( n1 -- a n2)
+  abs s>d <# #s #> dup 2/ 0<> over 1 and 0<> and
+  if 2/ 1- chars + 3 else drop 0 then
+;

Task/Middle-three-digits/Fortran/middle-three-digits.f

@@ -0,0 +1,73 @@
+!-*- mode: compilation; default-directory: "/tmp/" -*-
+!Compilation started at Sat Jun  1 14:48:41
+!
+!a=./f && make $a && OMP_NUM_THREADS=2 $a < unixdict.txt # some of the compilation options and redirection from unixdict.txt are vestigial.
+!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none f.f08 -o f
+!                 123  123
+!               12345  234
+!             1234567  345
+!           987654321  654
+!               10001  000
+!              -10001  000
+!                -123  123
+!                -100  100
+!                 100  100
+!              -12345  234
+!                   1  Too short
+!                   2  Too short
+!                  -1  Too short
+!                 -10  Too short
+!                2002  Digit count too even
+!               -2002  Digit count too even
+!                   0  Too short
+!
+!Compilation finished at Sat Jun  1 14:48:41
+
+
+program MiddleMuddle
+  integer, dimension(17) :: itest, idigits
+  integer :: i, n
+  data itest/123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,1,2,-1,-10,2002,-2002,0/
+  do i = 1, size(itest)
+    call antibase(10, abs(itest(i)), idigits, n)
+    write(6,'(i20,2x,a20)') itest(i), classifym3(idigits, n)
+    if (0 .eq. itest(i)) exit
+  end do
+
+contains
+
+  logical function even(n)
+    integer, intent(in) :: n
+    even = 0 .eq. iand(n,1)
+  end function even
+
+  function classifym3(iarray, n) result(s)
+    integer, dimension(:), intent(in) :: iarray
+    integer, intent(in) :: n
+    character(len=20) :: s
+    integer :: i,m
+    if (n < 3) then
+      s = 'Too short'
+    else if (even(n)) then
+      s = 'Digit count too even'
+    else
+      m = (n+1)/2
+      write(s,'(3i1)')(iarray(i), i=m+1,m-1,-1)
+    end if
+  end function classifym3
+
+  subroutine antibase(base, m, digits, n) ! digits ordered by increasing significance
+    integer, intent(in) :: base, m
+    integer, intent(out) :: n  ! the number of digits
+    integer, dimension(:), intent(out) :: digits
+    integer :: em
+    em = m
+    do n=1, size(digits)
+      digits(n) = mod(em, base)
+      em = em / base
+      if (0 .eq. em) return
+    end do
+    stop 'antibase ran out of space to store result'
+  end subroutine antibase
+
+end program MiddleMuddle

Task/Middle-three-digits/FreeBASIC/middle-three-digits.basic

@@ -0,0 +1,32 @@
+' FB 1.05.0 Win64
+
+Function middleThreeDigits (n As Integer) As String
+  If n < 0 Then n = -n
+  If n < 100 Then Return ""  '' error code
+  If n < 1000 Then Return Str(n)
+  If n < 10000 Then Return ""
+  Dim ns As String = Str(n)
+  If Len(ns) Mod 2 = 0 Then Return ""  '' need to have an odd number of digits for there to be 3 middle
+  Return Mid(ns, Len(ns) \ 2, 3)
+End Function
+
+Dim a(1 To 16) As Integer => _
+{123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -123451, 2, -1, -10, 2002, -2002, 0}
+
+Dim As Integer i
+Dim As String result
+
+Print "The 3 middle digits of the following numbers are : "
+Print
+For i = 1 To 16
+  result = middleThreeDigits(a(i))
+  Print a(i), " => ";
+  If result <> "" Then
+    Print result
+  Else
+    Print "Error: does not have 3 middle digits"
+  End If
+Next
+Print
+Print "Press any key to quit"
+Sleep

Task/Middle-three-digits/FutureBasic/middle-three-digits.basic

@@ -0,0 +1,33 @@
+local fn MiddleThreeDigits( n as NSInteger ) as CFStringRef
+  CFStringRef testStr, resultStr
+  NSInteger   length, middle
+
+  testStr = fn StringWithFormat( @"%ld", n )
+  testStr = fn StringByReplacingOccurrencesOfString( testStr, @"-", @"" )
+  length = len(testStr)
+  if length  < 3 then resultStr = fn StringWithFormat( @"%10ld -> Error: Less than three digits.", n ) : exit fn
+  if length == 3 then resultStr = fn StringWithFormat( @"%10ld -> %@", n, testStr ) : exit fn
+  length = len(testStr)
+  if ( length mod 2 == 0 )
+    resultStr = fn StringWithFormat( @"%10ld -> Error: Even length; needs odd.", n )
+  else
+    middle = length / 2
+    resultStr = fn StringWithFormat( @"%10ld -> %@", n, mid( testStr, middle -1, 3 ) )
+  end if
+end fn = resultStr
+
+window 1, @"Middle Three Digits", ( 0, 0, 400, 300 )
+
+NSUInteger  i, count
+CFArrayRef  testArr
+CFNumberRef tempNum
+
+testArr = @[@123,@12345,@1234567,@987654321,@10001,@-10001,¬
+@-123,@-100,@100,@-12345,@1,@2,@-1,@-10,@2002,@-2002,@0]
+
+count = fn ArrayCount( testArr )
+for i = 0 to count - 1
+  print fn MiddleThreeDigits( fn NumberIntegerValue( testArr[i] ) )
+next
+
+HandleEvents

Task/Middle-three-digits/Gambas/middle-three-digits.gambas

@@ -0,0 +1,24 @@
+Public Sub Main()
+Dim iList As Integer[] = [123, 12345, 1234567, 987654321, 10001,
+ -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0]    'Array of integers to process
+Dim sTemp As String                                                 'Temp string
+Dim siCount As Short                                                'Counter
+Dim sAnswer As New String[]                                         'Array, resons for failure or 'middle three digits'
+
+For siCount = 0 To iList.Max                                        'Loop through the integers
+  sTemp = Str(Abs(iList[siCount]))                                  'Convert integer to positive and place in sTemp as a string
+  If Len(sTemp) < 3 Then                                            'If sTemp has less than 3 characters then..
+    sAnswer.Add("This integer has less than 3 characters")          'Place text in sAnswers
+  Else If Even(Len(sTemp)) Then                                     'Else If sTemp is of even length then
+    sAnswer.Add("This integer has an even length")                  'Place text in sAnswers
+  Else                                                              'Else..
+    sAnswer.Add(Mid(sTemp, Int(Len(sTemp) / 2), 3))                 'Place the middle 3 digits in sAnswer
+  Endif
+Next
+
+For siCount = 0 To iList.Max                                        'Loop through the integers
+  Print Space$(10 - Len(Str(iList[siCount]))) &
+    iList[siCount] & " : " & sAnswer[siCount]                       'Print out results
+Next
+
+End

Task/Middle-three-digits/Go/middle-three-digits-1.go

@@ -0,0 +1,26 @@
+package m3
+
+import (
+    "errors"
+    "strconv"
+)
+
+var (
+    ErrorLT3  = errors.New("N of at least three digits required.")
+    ErrorEven = errors.New("N with odd number of digits required.")
+)
+
+func Digits(i int) (string, error) {
+    if i < 0 {
+        i = -i
+    }
+    if i < 100 {
+        return "", ErrorLT3
+    }
+    s := strconv.Itoa(i)
+    if len(s)%2 == 0 {
+        return "", ErrorEven
+    }
+    m := len(s) / 2
+    return s[m-1 : m+2], nil
+}

Task/Middle-three-digits/Go/middle-three-digits-2.go

@@ -0,0 +1,59 @@
+package m3_test
+
+import (
+    "testing"
+
+    "m3"
+)
+
+func TestPassing(t *testing.T) {
+    type s struct {
+        i int
+        m string
+    }
+    tcs := []s{
+        {123, "123"},
+        {12345, "234"},
+        {1234567, "345"},
+        {987654321, "654"},
+        {10001, "000"},
+        {-10001, "000"},
+    }
+    for _, tc := range tcs {
+        m, err := m3.Digits(tc.i)
+        if err != nil {
+            t.Fatalf("d(%d) returned %q.", tc.i, err)
+        }
+        if m != tc.m {
+            t.Fatalf("d(%d) expected %q, got %q.", tc.i, tc.m, m)
+        }
+        t.Logf("d(%d) = %q.", tc.i, m)
+    }
+}
+
+func TestFailing(t *testing.T) {
+    type s struct {
+        i   int
+        err error
+    }
+    tcs := []s{
+        {1, m3.ErrorLT3},
+        {2, m3.ErrorLT3},
+        {-1, m3.ErrorLT3},
+        {-10, m3.ErrorLT3},
+        {2002, m3.ErrorEven},
+        {-2002, m3.ErrorEven},
+        {0, m3.ErrorLT3},
+    }
+    for _, tc := range tcs {
+        m, err := m3.Digits(tc.i)
+        if err == nil {
+            t.Fatal("d(%d) expected error %q, got non-error %q.",
+                tc.i, tc.err, m)
+        }
+        if err != tc.err {
+            t.Fatal("d(d) expected error %q, got %q", tc.i, tc.err, err)
+        }
+        t.Logf("d(%d) returns %q", tc.i, err)
+    }
+}

Task/Middle-three-digits/Gosu/middle-three-digits.gosu

@@ -0,0 +1,13 @@
+var valid = {123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345}
+valid.each(\ num ->print(middleThree(num)))
+
+var errant = {1, 2, -1, -10, 2002, -2002, 0}
+errant.each(\ num ->print(middleThree(num)))
+
+function middleThree(x: int) : String {
+  var s = Math.abs(x) as String
+  if(s.length < 3) return "Error: ${x} has less than 3 digits"
+  if(s.length % 2 == 0) return "Error: ${x} has an even number of digits"
+  var start = (s.length / 2) - 1
+  return s.substring(start, start + 3)
+}

Task/Middle-three-digits/Groovy/middle-three-digits-1.groovy

@@ -0,0 +1,8 @@
+def middleThree(Number number) {
+    def text = Math.abs(number) as String
+    assert text.size() >= 3 : "'$number' must be more than 3 numeric digits"
+    assert text.size() % 2 == 1 : "'$number' must have an odd number of digits"
+
+    int start = text.size() / 2 - 1
+    text[start..(start+2)]
+}

Task/Middle-three-digits/Groovy/middle-three-digits-2.groovy

@@ -0,0 +1,8 @@
+[123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0].each { number ->
+    def text = (number as String).padLeft(10)
+    try {
+        println "$text: ${middleThree(number)}"
+    } catch(AssertionError error) {
+        println "$text cannot be converted: $error.message"
+    }
+}

Task/Middle-three-digits/Haskell/middle-three-digits.hs

@@ -0,0 +1,43 @@
+------------------- MIDDLE THREE DIGITS ------------------
+
+mid3 :: Int -> Either String String
+mid3 n
+  | m < 100 = Left "too small"
+  | even lng = Left "even number of digits"
+  | otherwise = Right . take 3 $ drop ((lng - 3) `div` 2) s
+  where
+    m = abs n
+    s = show m
+    lng = length s
+
+--------------------------- TEST -------------------------
+main :: IO ()
+main = do
+  let xs =
+        [ 123
+        , 12345
+        , 1234567
+        , 987654321
+        , 10001
+        , -10001
+        , -123
+        , -100
+        , 100
+        , -12345
+        , 1
+        , 2
+        , -1
+        , -10
+        , 2002
+        , -2002
+        , 0
+        ]
+      w = maximum $ length . show <$> xs
+  (putStrLn . unlines) $
+    (\n ->
+       justifyRight w ' ' (show n) <>
+       " -> " <> either (concat . ("(" :) . (: [")"])) id (mid3 n)) <$>
+    xs
+
+justifyRight :: Int -> Char -> String -> String
+justifyRight n c = (drop . length) <*> (replicate n c <>)

Task/Middle-three-digits/IS-BASIC/middle-three-digits.basic

@@ -0,0 +1,9 @@
+100 INPUT PROMPT "Number: ":N
+120 PRINT MIDDLE$(N)
+130 DEF MIDDLE$(N)
+140   LET N$=STR$(ABS(N))
+150   IF LEN(N$)<3 THEN LET MIDDLE$="Not enough digits":EXIT DEF
+160   IF MOD(LEN(N$),2)=0 THEN LET MIDDLE$="Even number of digits":EXIT DEF
+170   LET P=(LEN(N$)-3)/2
+180   LET MIDDLE$=N$(P+1:P+3)
+190 END DEF

Task/Middle-three-digits/Icon/middle-three-digits.icon

@@ -0,0 +1,12 @@
+procedure main(a)
+   every n := !a do write(right(n,15)," -> ",midM(n))
+end
+
+procedure midM(n,m)
+   /m := 3
+   n := abs(n)
+   return n ? if (*n >= m) then
+                 if (((*n-m) % 2) = 0) then (move((*n - m)/2),move(m))
+                 else "wrong number of digits"
+              else "too short"
+end

Task/Middle-three-digits/J/middle-three-digits-1.j

@@ -0,0 +1,4 @@
+asString=: ":"0                NB. convert vals to strings
+getPfxSize=: [: -:@| 3 -~ #    NB. get size of prefix to drop before the 3 middle digits
+getMid3=: (3 {. getPfxSize }. ,&'err') :: ('err'"_)  NB. get 3 middle digits or return 'err'
+getMiddle3=: getMid3@asString@:|

Task/Middle-three-digits/J/middle-three-digits-2.j

@@ -0,0 +1,19 @@
+   vals=: 123 12345 1234567 987654321 10001 _10001 _123 _100 100 _12345  1 2 _1 _10 2002 _2002 0
+   getMiddle3 vals
+123
+234
+345
+654
+000
+000
+123
+100
+100
+234
+err
+err
+err
+err
+err
+err
+err

Task/Middle-three-digits/J/middle-three-digits-3.j

@@ -0,0 +1,18 @@
+   ({~ 2 1 0 -~ -:@>:@#) ::('err'"_)@":@| vals
+123
+234
+345
+654
+000
+000
+123
+100
+100
+234
+err
+err
+err
+err
+err
+err
+err

Task/Middle-three-digits/Java/middle-three-digits.java

@@ -0,0 +1,27 @@
+public class MiddleThreeDigits {
+
+    public static void main(String[] args) {
+        final long[] passing = {123, 12345, 1234567, 987654321, 10001, -10001,
+            -123, -100, 100, -12345, Long.MIN_VALUE, Long.MAX_VALUE};
+
+        final int[] failing = {1, 2, -1, -10, 2002, -2002, 0, Integer.MIN_VALUE,
+            Integer.MAX_VALUE};
+
+        for (long n : passing)
+            System.out.printf("middleThreeDigits(%s): %s\n", n, middleThreeDigits(n));
+
+        for (int n : failing)
+            System.out.printf("middleThreeDigits(%s): %s\n", n, middleThreeDigits(n));
+    }
+
+    public static <T> String middleThreeDigits(T n) {
+        String s = String.valueOf(n);
+        if (s.charAt(0) == '-')
+            s = s.substring(1);
+        int len = s.length();
+        if (len < 3 || len % 2 == 0)
+            return "Need odd and >= 3 digits";
+        int mid = len / 2;
+        return s.substring(mid - 1, mid + 2);
+    }
+}

Task/Middle-three-digits/JavaScript/middle-three-digits-1.js

@@ -0,0 +1,10 @@
+function middleThree(x){
+  var n=''+Math.abs(x); var l=n.length-1;
+  if(l<2||l%2) throw new Error(x+': Invalid length '+(l+1));
+  return n.slice(l/2-1,l/2+2);
+}
+
+[123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345,
+1, 2, -1, -10, 2002, -2002, 0].forEach(function(n){
+  try{console.log(n,middleThree(n))}catch(e){console.error(e.message)}
+});

Task/Middle-three-digits/JavaScript/middle-three-digits-2.js

@@ -0,0 +1,126 @@
+(() => {
+    'use strict';
+
+    // mid3digits :: Int -> Either String String
+    const mid3digits = n => {
+        const
+            m = abs(n),
+            s = m.toString();
+        return 100 > m ? (
+            Left('Less than 3 digits')
+        ) : even(length(s)) ? (
+            Left('Even digit count')
+        ) : Right(take(3, drop(quot(length(s) - 3, 2), s)));
+    };
+
+    // TEST -----------------------------------------------
+    const main = () => {
+        const
+            xs = [
+                123, 12345, 1234567, 987654321, 10001, -10001, -123,
+                -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0
+            ],
+            w = maximum(map(x => x.toString().length, xs));
+        return (
+            unlines(map(
+                n => justifyRight(w, ' ', n.toString()) + ' -> ' +
+                either(
+                    s => '(' + s + ')',
+                    id,
+                    mid3digits(n)
+                ),
+                xs
+            ))
+        );
+    };
+
+    // GENERIC FUNCTIONS ----------------------------------
+
+    // Left :: a -> Either a b
+    const Left = x => ({
+        type: 'Either',
+        Left: x
+    });
+
+    // Right :: b -> Either a b
+    const Right = x => ({
+        type: 'Either',
+        Right: x
+    });
+
+    // abs :: Num -> Num
+    const abs = Math.abs;
+
+    // drop :: Int -> [a] -> [a]
+    // drop :: Int -> Generator [a] -> Generator [a]
+    // drop :: Int -> String -> String
+    const drop = (n, xs) =>
+        Infinity > length(xs) ? (
+            xs.slice(n)
+        ) : (take(n, xs), xs);
+
+    // either :: (a -> c) -> (b -> c) -> Either a b -> c
+    const either = (fl, fr, e) =>
+        'Either' === e.type ? (
+            undefined !== e.Left ? (
+                fl(e.Left)
+            ) : fr(e.Right)
+        ) : undefined;
+
+    // even :: Int -> Bool
+    const even = n => 0 === n % 2;
+
+    // foldl1 :: (a -> a -> a) -> [a] -> a
+    const foldl1 = (f, xs) =>
+        1 < xs.length ? xs.slice(1)
+        .reduce(f, xs[0]) : xs[0];
+
+    // id :: a -> a
+    const id = x => x;
+
+    // justifyRight :: Int -> Char -> String -> String
+    const justifyRight = (n, cFiller, s) =>
+        n > s.length ? (
+            s.padStart(n, cFiller)
+        ) : s;
+
+    // Returns Infinity over objects without finite length.
+    // This enables zip and zipWith to choose the shorter
+    // argument when one is non-finite, like cycle, repeat etc
+
+    // length :: [a] -> Int
+    const length = xs =>
+        (Array.isArray(xs) || 'string' === typeof xs) ? (
+            xs.length
+        ) : Infinity;
+
+    // maximum :: Ord a => [a] -> a
+    const maximum = xs =>
+        0 < xs.length ? (
+            foldl1((a, x) => x > a ? x : a, xs)
+        ) : undefined;
+
+    // map :: (a -> b) -> [a] -> [b]
+    const map = (f, xs) => xs.map(f);
+
+    // quot :: Int -> Int -> Int
+    const quot = (n, m) => Math.floor(n / m);
+
+    // take :: Int -> [a] -> [a]
+    // take :: Int -> String -> String
+    const take = (n, xs) =>
+        'GeneratorFunction' !== xs.constructor.constructor.name ? (
+            xs.slice(0, n)
+        ) : [].concat.apply([], Array.from({
+            length: n
+        }, () => {
+            const x = xs.next();
+            return x.done ? [] : [x.value];
+        }));
+
+    // unlines :: [String] -> String
+    const unlines = xs => xs.join('\n');
+
+    // MAIN ---
+    return main();
+})();

Task/Middle-three-digits/Jq/middle-three-digits-1.jq

@@ -0,0 +1,10 @@
+def middle3:
+  if . <  0 then -. else . end
+  | tostring as $s
+  | ($s | length) as $n
+  | if $n<3 or ($n % 2) == 0 then "invalid length: \($n)"
+    else (($n - 1) / 2) as $n |  $s[$n - 1 : $n + 2]
+    end ;
+
+(123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0)
+  | "\(.) => \( .|middle3 )"

Task/Middle-three-digits/Jq/middle-three-digits-2.jq

@@ -0,0 +1,18 @@
+ $ jq -r -n -f Middle_three_digits.jq
+123 => 123
+12345 => 234
+1234567 => 345
+987654321 => 654
+10001 => 000
+-10001 => 000
+-123 => 123
+-100 => 100
+100 => 100
+-12345 => 234
+1 => invalid length: 1
+2 => invalid length: 1
+-1 => invalid length: 1
+-10 => invalid length: 2
+2002 => invalid length: 4
+-2002 => invalid length: 4
+0 => invalid length: 1

Task/Middle-three-digits/Julia/middle-three-digits.julia

@@ -0,0 +1,14 @@
+using Printf
+
+function middle3(n::Integer)
+    l = ndigits(n)
+    iseven(l) && error("n must have an odd number of digits")
+    l < 3 && error("n must have 3 digits or more")
+    mid = (l + 1) ÷ 2
+    abs(n) ÷ 10^(mid-2) % 10^3
+end
+
+for n = [123, 12345, 1234567, 987654321, 10001, -10001, -123,
+         -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0]
+    @printf("%10d -> %s\n", n, try middle3(n) catch e e.msg end)
+end

Task/Middle-three-digits/K/middle-three-digits.k

@@ -0,0 +1,3 @@
+/ Rosetta code - Middle three digits
+/ mid3.k
+mid3: {qs:$x;:[qs[0]="-";qs: 1 _ qs];:[(#qs)<3;:"small";(1+#qs)!2;:"even"];p:(-3+#qs)%2;:(|p _|p _ qs)}

Task/Middle-three-digits/Klingphix/middle-three-digits.klingphix

@@ -0,0 +1,14 @@
+include ..\Utilitys.tlhy
+
+( 123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345 1 2 -1 -10 2002 -2002 0 )
+
+len [
+        get ( dup " : " ) lprint
+        abs tostr len >ps
+        tps 3 < ( ["too short" ?]
+                  [ tps 2 mod ( [tps 2 / 3 slice ?] ["is even" ?] ) if]
+                ) if
+        ps> drop drop
+    ] for
+
+" " input

Task/Middle-three-digits/Klong/middle-three-digits.klong

@@ -0,0 +1,4 @@
+items::[123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345 1 2 -1 -10 2002 -2002 0]
+
+mid3::{[d k];:[3>k::#$#x;"small":|0=k!2;"even";(-d)_(d::_(k%2)-1)_$#x]}
+.p(mid3'items)

Task/Middle-three-digits/Kotlin/middle-three-digits.kotlin

@@ -0,0 +1,16 @@
+fun middleThree(x: Int): Int? {
+    val s = Math.abs(x).toString()
+    return when {
+        s.length < 3 -> null // throw Exception("too short!")
+        s.length % 2 == 0 -> null // throw Exception("even number of digits")
+        else -> ((s.length / 2) - 1).let { s.substring(it, it + 3) }.toInt()
+    }
+}
+
+fun main(args: Array<String>) {
+    println(middleThree(12345)) // 234
+    println(middleThree(1234)) // null
+    println(middleThree(1234567)) // 345
+    println(middleThree(123))// 123
+    println(middleThree(123555)) //null
+}

Task/Middle-three-digits/Lambdatalk/middle-three-digits.lambdatalk

@@ -0,0 +1,41 @@
+{def S 123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345
+       1 2 -1 -10 2002 -2002 0}
+-> S
+
+{def middle3digits
+ {lambda {:w}
+  {let { {:w {abs :w}}
+         {:l {W.length {abs :w}}}
+       } {if {= {% :l 2} 0}
+          then has an even number of digits
+          else {if {< :l 3}
+          then has not enough digits
+          else {W.get {- {/ :l 2} 1} :w}
+               {W.get {/ :l 2} :w}
+               {W.get {+ {/ :l 2} 1} :w} }}}}}
+-> middle3digits
+
+
+{table
+{S.map {lambda {:i}
+       {tr {td {@ style="text-align:right;"}:i:}
+           {td {middle3digits :i}}}}
+       {S}} }
+->
+   123: 	123
+   12345: 	234
+   1234567: 	345
+ 987654321: 	654
+     10001: 	000
+    -10001: 	000
+      -123: 	123
+      -100: 	100
+       100: 	100
+    -12345: 	234
+         1: 	has not enough digits
+         2: 	has not enough digits
+        -1: 	has not enough digits
+       -10: 	has an even number of digits
+      2002: 	has an even number of digits
+     -2002: 	has an even number of digits
+         0: 	has not enough digits

Task/Middle-three-digits/Lasso/middle-three-digits.lasso

@@ -0,0 +1,22 @@
+define middlethree(value::integer) => {
+	local(
+		pos_value	= math_abs(#value),
+		stringvalue	= #pos_value -> asstring,
+		intlength	= #stringvalue -> size,
+		middle		= integer((#intlength + 1) / 2),
+		prefix		= string(#value) -> padleading(15)& + ': '
+	)
+
+	#intlength < 3 ? return #prefix + 'Error: too few digits'
+	not(#intlength % 2) ? return #prefix + 'Error: even number of digits'
+
+	return #prefix + #stringvalue -> sub(#middle -1, 3)
+
+}
+'<pre>'
+with number in array(123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0) do {^
+
+	middlethree(#number)
+	'<br />'
+^}
+'</pre>'

Task/Middle-three-digits/Logo/middle-three-digits.logo

@@ -0,0 +1,19 @@
+to middle3digits :n
+  if [less? :n 0] [make "n minus :n]
+  local "len make "len count :n
+  if [less? :len 3] [(throw "error [Number must have at least 3 digits])]
+  if [equal? 0 modulo :len 2] [(throw "error [Number must have odd number of digits])]
+  while [greater? count :n 3] [
+    make "n butlast butfirst :n
+  ]
+  output :n
+end
+
+foreach [123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345
+         1 2 -1 -10 2002 -2002 0] [
+    type sentence (word ? ": char 9) runresult [if [less? count ? 7] [char 9]]
+    make "mid runresult [catch "error [middle3digits ?]]
+    print ifelse [empty? :mid] [item 2 error] [:mid]
+]
+
+bye

Task/Middle-three-digits/Lua/middle-three-digits.lua

@@ -0,0 +1,26 @@
+function middle_three(n)
+	if n < 0 then
+		n = -n
+	end
+		
+	n = tostring(n)
+	if #n % 2 == 0 then
+		return "Error: the number of digits is even."
+	elseif #n < 3 then
+		return "Error: the number has less than 3 digits."
+	end
+
+	local l = math.floor(#n/2)
+	return n:sub(l, l+2)
+end
+
+-- test
+do
+	local t = {123, 12345, 1234567, 987654321,
+	10001, -10001, -123, -100, 100, -12345, 1,
+	2, -1, -10, 2002, -2002, 0}
+
+	for _,n in pairs(t) do
+		print(n, middle_three(n))	
+	end
+end

Task/Middle-three-digits/MATLAB/middle-three-digits-1.m

@@ -0,0 +1,15 @@
+function s=middle_three_digits(a)
+% http://rosettacode.org/wiki/Middle_three_digits
+
+s=num2str(abs(a));
+
+if ~mod(length(s),2)
+	s='*** error: number of digits must be odd ***';
+	return;
+end;
+if length(s)<3,
+	s='*** error: number of digits must not be smaller than 3 ***';
+	return;
+end;
+
+s = s((length(s)+1)/2+[-1:1]);

Task/Middle-three-digits/MATLAB/middle-three-digits-2.m

@@ -0,0 +1,2 @@
+ x=[123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0];
+for k=1:length(x); fprintf(1,'%9i:%s\n',x(k),middle_three_digits(x(k)));end;

Task/Middle-three-digits/MLite/middle-three-digits.mlite

@@ -0,0 +1,25 @@
+	val test_array = ["123","12345","1234567","987654321","10001","~10001","~123","~100","100","~12345","1","2","~1","~10","2002","~2002","0"];
+
+	fun even (x rem 2 = 0) = true | _ = false;
+
+	fun middleThreeDigits
+			(h :: t, s, 1 ) = s @ " --> too small"
+		|	(h :: t, s, 2 ) = s @ " --> has even digits"
+		|	(h :: t, s, 3 ) where (len (h :: t) = 3) = s @ " --> " @ (implode (h :: t))
+		|	(h :: t, s, 3 ) = (middleThreeDigits ( sub (t, 0, (len t)-1), s, 3))
+		|	(h :: t, s, m) = if len (h :: t) < 3 then
+							middleThreeDigits (h :: t, s, 1)
+						  else
+						    if even ` len (h :: t) then
+							  middleThreeDigits (h :: t, s, 2)
+							else
+							  middleThreeDigits (h :: t, s, 3)
+
+
+		|	s	= if sub (s, 0, 1) = "~" then
+				middleThreeDigits (sub (explode s, 1, len s), s, 0)
+			else
+				middleThreeDigits (explode s, s, 0)
+	;
+
+	map (println o middleThreeDigits) test_array;

Task/Middle-three-digits/MUMPS/middle-three-digits.mumps

@@ -0,0 +1,10 @@
+/* MUMPS */
+MID3(N)  ;
+        N LEN,N2
+        S N2=$S(N<0:-N,1:N)
+        I N2<100 Q "NUMBER TOO SMALL"
+        S LEN=$L(N2)
+        I LEN#2=0 Q "EVEN NUMBER OF DIGITS"
+        Q $E(N2,LEN\2,LEN\2+2)
+
+F I=123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,1,2,-1,-10,2002,-2002,0 W !,$J(I,10),": ",$$MID3^MID3(I)

Task/Middle-three-digits/Maple/middle-three-digits.maple

@@ -0,0 +1,19 @@
+middleDigits := proc(n)
+	local nList, start;
+	nList := [seq(parse(i), i in convert (abs(n), string))];
+	if numelems(nList) < 3 then
+		printf ("%9a: Error: Not enough digits.", n);
+	elif numelems(nList) mod 2 = 0 then
+		printf ("%9a: Error: Even number of digits.", n);
+	else
+		start := (numelems(nList)-1)/2;
+		printf("%9a: %a%a%a", n, op(nList[start..start+2]));
+	end if;
+end proc:
+
+a := [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345,
+	 1, 2, -1, -10, 2002, -2002, 0]:
+for i in a do
+	middleDigits(i);
+	printf("\n");
+end do;

Task/Middle-three-digits/Mathematica/middle-three-digits.math

@@ -0,0 +1,11 @@
+middleThree[n_Integer] :=
+ Block[{digits = IntegerDigits[n], len},
+  len = Length[digits];
+  If[len < 3 || EvenQ[len], "number digits odd or less than 3",
+   len = Ceiling[len/2];
+   StringJoin @@ (ToString /@ digits[[len - 1 ;; len + 1]])]]
+
+testData = {123, 12345, 1234567, 987654321, 10001, -10001, -123, -100,
+    100, -12345, 1, 2, -1, -10, 2002, -2002, 0};
+
+Column[middleThree /@ testData]

Task/Middle-three-digits/MiniScript/middle-three-digits.mini

@@ -0,0 +1,13 @@
+middle3 = function(num)
+    if num < 0 then num = -num
+    s = str(num)
+    if s.len < 3 then return "Input too short"
+    if s.len % 2 == 0 then return "Input length not odd"
+    mid = (s.len + 1) / 2 - 1
+    return s[mid-1:mid+2]
+end function
+
+for test in [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100,
+ 100, -12345, 1, 2, -1, -10, 2002, -2002, 0]
+    print test + " --> " + middle3(test)
+end for

Task/Middle-three-digits/NetRexx/middle-three-digits.netrexx

@@ -0,0 +1,46 @@
+/* NetRexx */
+options replace format comments java crossref symbols nobinary
+
+sl = '123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345' -
+     '1 2 -1 -10 2002 -2002 0' -
+     'abc 1e3 -17e-3 4004.5 12345678 9876543210' -- extras
+
+parse arg digsL digsR .
+if \digsL.datatype('w') then digsL = 3
+if \digsR.datatype('w') then digsR = digsL
+if digsL > digsR        then digsR = digsL
+
+loop dc = digsL to digsR
+  say 'Middle' dc 'characters'
+  loop nn = 1 to sl.words()
+    val = sl.word(nn)
+    say middleDigits(dc, val)
+    end nn
+  say
+  end dc
+return
+
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+method middle3Digits(val) constant
+  return middleDigits(3, val)
+
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+method middleDigits(digitCt, val) constant
+  text = val.right(15)':'
+  even = digitCt // 2 == 0 -- odd or even?
+  select
+    when digitCt <= 0                       then text = 'digit selection size must be >= 1'
+    when \val.datatype('w')                 then text = text 'is not a whole number'
+    when val.abs().length < digitCt         then text = text 'has less than' digitCt 'digits'
+    when \even & val.abs().length // 2 == 0 then text = text 'does not have an odd number of digits'
+    when even  & val.abs().length // 2 \= 0 then text = text 'does not have an even number of digits'
+    otherwise do
+      val = val.abs()
+      valL = val.length
+      cutP = (valL - digitCt) % 2
+      text = text val.substr(cutP + 1, digitCt)
+      end
+    catch NumberFormatException
+      text = val 'is not numeric'
+    end
+  return text

Task/Middle-three-digits/NewLISP/middle-three-digits.l

@@ -0,0 +1,11 @@
+(define (middle3 x)
+    (if (even? (length x))
+        (println "You entered " x ". I need an odd number of digits, not " (length x) ".")
+        (if (< (length x) 3)
+            (println "You entered " x ". Sorry, but I need 3 or more digits.")
+            (println "The middle 3 digits of " x " are " ((- (/ (- (length x) 1) 2) 1) 3 (string (abs x))) ".")
+        )
+    )
+)
+
+(map middle3 lst)

Task/Middle-three-digits/Nim/middle-three-digits.nim

@@ -0,0 +1,14 @@
+proc middleThreeDigits(i: int): string =
+  var s = $abs(i)
+  if s.len < 3 or s.len mod 2 == 0:
+    raise newException(ValueError, "Need odd and >= 3 digits")
+  let mid = s.len div 2
+  return s[mid-1..mid+1]
+
+const passing = @[123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345]
+const failing = @[1, 2, -1, -10, 2002, -2002, 0]
+
+for i in passing & failing:
+  var answer = try: middleThreeDigits(i)
+               except ValueError: getCurrentExceptionMsg()
+  echo "middleThreeDigits(", i, ") returned: ", answer

Task/Middle-three-digits/OCaml/middle-three-digits.ocaml

@@ -0,0 +1,25 @@
+let even x = (x land 1) <> 1
+
+let middle_three_digits x =
+  let s = string_of_int (abs x) in
+  let n = String.length s in
+  if n < 3 then failwith "need >= 3 digits" else
+  if even n then failwith "need odd number of digits" else
+  String.sub s (n / 2 - 1) 3
+
+let passing = [123; 12345; 1234567; 987654321; 10001; -10001; -123; -100; 100; -12345]
+let failing = [1; 2; -1; -10; 2002; -2002; 0]
+
+let print x =
+  let res =
+    try (middle_three_digits x)
+    with Failure e -> "failure: " ^ e
+  in
+  Printf.printf "%d: %s\n" x res
+
+let () =
+  print_endline "Should pass:";
+  List.iter print passing;
+  print_endline "Should fail:";
+  List.iter print failing;
+;;

Task/Middle-three-digits/Objeck/middle-three-digits.objeck

@@ -0,0 +1,13 @@
+class Test {
+  function : Main(args : String[]) ~ Nil {
+    text := "123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0";
+    ins := text->Split(",");
+    each(i : ins) {
+      in := ins[i]->Trim();
+      IO.Console->Print(in)->Print(": ");
+      in := (in->Size() > 0 & in->Get(0) = '-') ? in->SubString(1, in->Size() - 1) : in;
+      IO.Console->PrintLine((in->Size() < 2 | in->Size() % 2 = 0) ? "Error" : in->SubString((in->Size() - 3) / 2, 3));
+    };
+  }
+
+}

Task/Middle-three-digits/Oforth/middle-three-digits.fth

@@ -0,0 +1,6 @@
+: middle3
+| s sz |
+   abs asString dup ->s size ->sz
+   sz 3 <    ifTrue: [ "Too short" println return ]
+   sz isEven ifTrue: [ "Not odd number of digits" println return ]
+   sz 3 - 2 / 1+  dup 2 + s extract ;

Task/Middle-three-digits/PARI-GP/middle-three-digits-1.parigp

@@ -0,0 +1,2 @@
+middle(n)=my(v=digits(n));if(#v>2&&#v%2,100*v[#v\2]+10*v[#v\2+1]+v[#v\2+2],"no middle 3 digits");
+apply(middle,[123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0])

Task/Middle-three-digits/PARI-GP/middle-three-digits-2.parigp

@@ -0,0 +1 @@
+apply(n-> Strprintf("%03d", n), %)

Task/Middle-three-digits/PARI-GP/middle-three-digits-3.parigp

@@ -0,0 +1 @@
+digits(n)=eval(Vec(Str(n)))

Task/Middle-three-digits/PARI-GP/middle-three-digits-4.parigp

@@ -0,0 +1 @@
+digits(n)=Vec(apply(n->n-48,Vectorsmall(Str(n))))

Task/Middle-three-digits/PHP/middle-three-digits.php

@@ -0,0 +1,39 @@
+// 32-bit builds of PHP: Integers can be from -2147483648 to 2147483647
+// 64-bit builds of PHP: Integers can be from -9223372036854775808 to 9223372036854775807
+
+function middlethree($integer)
+{
+	$int 	= (int)str_replace('-','',$integer);
+	$length = strlen($int);
+
+	if(is_int($int))
+	{
+		if($length >= 3)
+		{
+			if($length % 2 == 1)
+			{
+				$middle = floor($length / 2) - 1;
+				return substr($int,$middle, 3);
+			}
+			else
+			{
+				return 'The value must contain an odd amount of digits...';	
+			}
+		}
+		else
+		{
+			return 'The value must contain at least three digits...';	
+		}
+	}
+	else
+	{
+		return 'The value does not appear to be an integer...';
+	}
+}
+
+$numbers = array(123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0);
+
+foreach($numbers as $nums)
+{
+	echo $nums.' : '.middlethree($nums). '<br>';
+}

Task/Middle-three-digits/PL-I/middle-three-digits.pli

@@ -0,0 +1,24 @@
+middle: procedure options (main);      /* 29 October 2013 */
+   declare n fixed (15);
+   declare s character (25) varying;
+   declare in file input;
+
+   open file (in) title ('/MIDDLE.DAT,type(text),recsize(100)');
+   on endfile (in) stop;
+
+   do forever;
+      get file (in) list (n); put skip list (n);
+      n = abs(n);
+      s = trim(n);
+      if length(s) < 3 then put list ('not possible');
+      else  if mod(length(s), 2) = 0 then put list ('not possible');
+      else
+         do;
+            do while (length(s) > 3);
+               s = substr(s, 2, length(s)-2);
+            end;
+            put list ('The middle three digits are: ' || s);
+         end;
+   end;
+
+end middle;

Task/Middle-three-digits/Pascal/middle-three-digits.pas

@@ -0,0 +1,37 @@
+program Midl3dig;
+{$IFDEF FPC}
+  {$MODE Delphi} //result /integer => Int32 aka longInt etc..
+{$ELSE}
+  {$APPTYPE console} // Delphi
+{$ENDIF}
+uses
+  sysutils;   //IntToStr
+function GetMid3dig(i:NativeInt):Ansistring;
+var
+  n,l: NativeInt;
+Begin
+  setlength(result,0);
+  //n = |i| jumpless abs
+  n := i-((ORD(i>0)-1)AND (2*i));
+  //calculate digitcount
+  IF n > 0 then
+    l := trunc(ln(n)/ln(10))+1
+  else
+    l := 1;
+  if l<3 then Begin  write('got too few digits');  EXIT; end;
+  If Not(ODD(l)) then Begin write('got even number of digits'); EXIT; end;
+  result:= copy(IntToStr(n),l DIV 2,3);
+end;
+const
+  Test : array [0..16] of NativeInt =
+    ( 123,12345,1234567,987654321,10001,-10001,
+    -123,-100,100,-12345,1,2,-1,-10,2002,-2002,0);
+var
+  i,n : NativeInt;
+Begin
+  For i := low(Test) to High(Test) do
+  Begin
+    n := Test[i];
+    writeln(n:9,': ',GetMid3dig(Test[i]));
+  end;
+end.

Task/Middle-three-digits/Perl/middle-three-digits.pl

@@ -0,0 +1,25 @@
+#!/usr/bin/perl
+use strict ;
+use warnings ;
+
+sub middlethree {
+   my $number = shift ;
+   my $testnumber = abs $number ;
+   my $error = "Middle 3 digits can't be shown" ;
+   my $numberlength = length $testnumber ;
+   if ( $numberlength < 3 ) {
+      print "$error : $number too short!\n" ;
+      return ;
+   }
+   if ( $numberlength % 2 == 0 ) {
+      print "$error : even number of digits in $number!\n" ;
+      return ;
+   }
+   my $middle = int ( $numberlength  / 2 ) ;
+   print "Middle 3 digits of $number : " . substr( $testnumber , $middle - 1 , 3 ) . " !\n" ;
+   return ;
+}
+
+my @numbers = ( 123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345 ,
+      1, 2, -1, -10, 2002, -2002, 0 ) ;
+map { middlethree( $_ ) } @numbers ;

Task/Middle-three-digits/Phix/middle-three-digits.phix

@@ -0,0 +1,13 @@
+(phixonline)-->
+ <span style="color: #008080;">procedure</span> <span style="color: #000000;">mid3</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">abs</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">))</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">k</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">3</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%10d: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">or</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)?</span><span style="color: #008000;">"error"</span><span style="color: #0000FF;">:</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">k</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">k</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">+</span><span style="color: #000000;">3</span><span style="color: #0000FF;">])})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
+
+ <span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">123</span><span style="color: #0000FF;">,</span><span style="color: #000000;">12345</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1234567</span><span style="color: #0000FF;">,</span><span style="color: #000000;">987654321</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10001</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">10001</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">123</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">100</span><span style="color: #0000FF;">,</span><span style="color: #000000;">100</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">12345</span><span style="color: #0000FF;">,</span>
+                   <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2002</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">2002</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">}</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+     <span style="color: #000000;">mid3</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+<!--

Task/Middle-three-digits/Picat/middle-three-digits-1.picat

@@ -0,0 +1,3 @@
+get_middle_f1(Str) = [X,Y,Z] =>
+  append(Pre,[X,Y,Z],Post,Str),
+  length(Pre) = length(Post).

Task/Middle-three-digits/Picat/middle-three-digits-2.picat

@@ -0,0 +1,2 @@
+get_middle_f2(Str) = Str[Mid-1..Mid+1] =>
+  Mid = 1 + Str.len div 2.

Task/Middle-three-digits/Picat/middle-three-digits-3.picat

@@ -0,0 +1,26 @@
+go =>
+  Success = [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345],
+  Fail = [1, 2, -1, -10, 2002, -2002, 0],
+  All = Success ++ Fail,
+
+  test(All, get_middle_f1),
+  test(All, get_middle_f2).
+
+% Test and check for exceptions
+test(List,F) =>
+  printf("\nTesting %w:\n", F),
+  foreach(N in List)
+    catch(Middle=apply(get_middle,N,F), E, printf("%d = exception %w\n",N,E)),
+    if E.var() then
+      println([n=N,middle=Middle])
+    end
+  end,
+  nl.
+
+% Check with the get_middle funcion F
+get_middle(N,F) = apply(F,Str) =>
+  Str = N.abs().to_string(),
+  Len = length(Str),
+  if Len mod 2 = 0 then throw $not_odd_length(N)
+  elseif Len < 3   then throw $number_too_small(N)
+  end.