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'); } }

## DCL

<lang>$ 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

{{out}}

$ @middle_three_digits
      123: 123
    12345: 234
  1234567: 345
987654321: 654
    10001: 000
   -10001: 000
     -123: 123
     -100: 100
      100: 100
   -12345: 234
        1: has no middle three
        2: has no middle three
       -1: has no middle three
      -10: has no middle three
     2002: has no middle three
    -2002: has no middle three
        0: has no middle three

Eiffel

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

{{out}}

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 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
The middle three digits of 1 are:      Not enough digits.
The middle three digits of 2 are:      Not enough digits.
The middle three digits of -1 are:     Not enough digits.
The middle three digits of -10 are:    Not enough digits.
The middle three digits of 2002 are:   Even number of digits.
The middle three digits of -2002 are:  Even number of digits.
The middle three digits of 0 are:      Not enough digits.

Elena

ELENA 4.1 :

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))
        }
}

{{out}}

middleThreeDigits(123):123
middleThreeDigits(12345):234
middleThreeDigits(1234567):345
middleThreeDigits(987654321):654
middleThreeDigits(10001):000
middleThreeDigits(-10001):000
middleThreeDigits(-123):123
middleThreeDigits(-100):100
middleThreeDigits(100):100
middleThreeDigits(-12345):234
middleThreeDigits(1):n must have 3 digits or more
middleThreeDigits(2):n must have 3 digits or more
middleThreeDigits(-1):n must have 3 digits or more
middleThreeDigits(-10):n must have 3 digits or more
middleThreeDigits(2002):n must have an odd number of digits
middleThreeDigits(-2002):n must have an odd number of digits
middleThreeDigits(0):n must have 3 digits or more

Elixir

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)

{{out}}

       123 : 123
     12345 : 234
   1234567 : 345
 987654321 : 654
     10001 : 000
    -10001 : 000
      -123 : 123
      -100 : 100
       100 : 100
    -12345 : 234
         1 : Number must have at least three digits
         2 : Number must have at least three digits
        -1 : Number must have at least three digits
       -10 : Number must have at least three digits
      2002 : Number must have an odd number of digits
     -2002 : Number must have an odd number of digits
         0 : Number must have at least three digits

Erlang

%
-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).

{{out}}

123
234
345
654
000
000
123
100
100
234
too small
too small
too small
too small
even number of digits
even number of digits
too small
ok

ERRE

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

{{out}}

 123          123
 12345        234
 1234567      345
 987654321    654
 10001        000
-10001        000
-123          123
-100          100
 100          100
-12345        234
 1            ?ONLY 1 DIGITS
 2            ?ONLY 1 DIGITS
-1            ?ONLY 1 DIGITS
-10           ?EVEN,ONLY 2 DIGIT
 2002         ?EVEN
-2002         ?EVEN
 0            ?ONLY 1 DIGITS

Factor

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

{{out}}

```txt

      123 : 123
    12345 : 234
  1234567 : 345
987654321 : 654
    10001 : 000
   -10001 : 000
     -123 : 123
     -100 : 100
      100 : 100
   -12345 : 234
        1 : Number must have at least three digits.
        2 : Number must have at least three digits.
       -1 : Number must have at least three digits.
      -10 : Number must have at least three digits.
     2002 : Number must have an odd number of digits.
    -2002 : Number must have an odd number of digits.
        0 : Number must have at least three digits.

Forth

This is a problem, which is easily solved in Forth. It converts the number to a string and checks it length. If the number does not represent a printable string, it returns an empty string.

: 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
;

Fortran

Please find compilation instructions along with the output for the examples in the comments at the beginning of the file. This program was produced in an Ubuntu distribution of the GNU/linux system.

!-*- 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

FreeBASIC

' 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

{{out}}

The 3 middle digits of the following numbers are :

 123           => 123
 12345         => 234
 1234567       => 345
 987654321     => 654
 10001         => 000
-10001         => 000
-123           => 123
-100           => 100
 100           => 100
-123451        => Error: does not have 3 middle digits
 2             => Error: does not have 3 middle digits
-1             => Error: does not have 3 middle digits
-10            => Error: does not have 3 middle digits
 2002          => Error: does not have 3 middle digits
-2002          => Error: does not have 3 middle digits
 0             => Error: does not have 3 middle digits

Gambas

'''[https://gambas-playground.proko.eu/?gist=ed25e84978446d65895ccd909fc092fa Click this link to run this code]'''

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

Output:

     12345 : 234
   1234567 : 345
 987654321 : 654
     10001 : 000
    -10001 : 000
      -123 : 123
      -100 : 100
       100 : 100
    -12345 : 234
         1 : This integer has less than 3 characters
         2 : This integer has less than 3 characters
        -1 : This integer has less than 3 characters
       -10 : This integer has less than 3 characters
      2002 : This integer has an even length
     -2002 : This integer has an even length
         0 : This integer has less than 3 characters

Go

Unlike most Go examples on RC, this is written as a package to show operation of the go test tool.

File m3.go:

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
}

File m3_test.go:

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)
    }
}

{{out}} Output of go test is normally terse:

> go test
PASS
ok      m3      0.008s

With -v (for verbose):

> go test -v
=== RUN TestPassing-4
--- PASS: TestPassing-4 (0.00 seconds)
        m3_test.go:30: d(123) = "123".
        m3_test.go:30: d(12345) = "234".
        m3_test.go:30: d(1234567) = "345".
        m3_test.go:30: d(987654321) = "654".
        m3_test.go:30: d(10001) = "000".
        m3_test.go:30: d(-10001) = "000".
=== RUN TestFailing-4
--- PASS: TestFailing-4 (0.00 seconds)
        m3_test.go:57: d(1) returns "N of at least three digits required."
        m3_test.go:57: d(2) returns "N of at least three digits required."
        m3_test.go:57: d(-1) returns "N of at least three digits required."
        m3_test.go:57: d(-10) returns "N of at least three digits required."
        m3_test.go:57: d(2002) returns "N with odd number of digits required."
        m3_test.go:57: d(-2002) returns "N with odd number of digits required."
        m3_test.go:57: d(0) returns "N of at least three digits required."
PASS
ok      m3      0.008s

Gosu

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)
}

{{Output}}

123
234
345
654
000
000
123
100
100
234
Error: 1 has less than 3 digits
Error: 2 has less than 3 digits
Error: -1 has less than 3 digits
Error: -10 has less than 3 digits
Error: 2002 has an even number of digits
Error: -2002 has an even number of digits
Error: 0 has less than 3 digits

Groovy

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)]
}

Test Code:

[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"
    }
}

Output:

       123: 123
     12345: 234
   1234567: 345
 987654321: 654
     10001: 000
    -10001: 000
      -123: 123
      -100: 100
       100: 100
    -12345: 234
         1 cannot be converted: '1' must be more than 3 numeric digits. Expression: (text.size() >= 3)
         2 cannot be converted: '2' must be more than 3 numeric digits. Expression: (text.size() >= 3)
        -1 cannot be converted: '-1' must be more than 3 numeric digits. Expression: (text.size() >= 3)
       -10 cannot be converted: '-10' must be more than 3 numeric digits. Expression: (text.size() >= 3)
      2002 cannot be converted: '2002' must have an odd number of digits. Expression: ((text.size() % 2) == 1)
     -2002 cannot be converted: '-2002' must have an odd number of digits. Expression: ((text.size() % 2) == 1)
         0 cannot be converted: '0' must be more than 3 numeric digits. Expression: (text.size() >= 3)

Haskell

mid3 :: Int -> Either String String
mid3 n
  | m < 100 = Left "is too small"
  | even lng = Left "has an 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 ((>>= id) . ("(" :) . (: [")"])) id (mid3 n)) <$>
    xs
  where
    justifyRight :: Int -> Char -> String -> String
    justifyRight n c s = drop (length s) (replicate n c ++ s)

Output:

      123 -> 123
    12345 -> 234
  1234567 -> 345
987654321 -> 654
    10001 -> 000
   -10001 -> 000
     -123 -> 123
     -100 -> 100
      100 -> 100
   -12345 -> 234
        1 -> (is too small)
        2 -> (is too small)
       -1 -> (is too small)
      -10 -> (is too small)
     2002 -> (has an even number of digits)
    -2002 -> (has an even number of digits)
        0 -> (is too small)

=={{header|Icon}} and {{header|Unicon}}==

The following solution works in both languages.

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

with output:

->m3d 123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345 1 2 -1 -10 2002 -2002 0
            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 -> wrong number of digits
          -2002 -> wrong number of digits
              0 -> too short
->

J

'''Solution:'''

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@:|

'''Example:'''

   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

Java

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);
    }
}

middleThreeDigits(123): 123
middleThreeDigits(12345): 234
middleThreeDigits(1234567): 345
middleThreeDigits(987654321): 654
middleThreeDigits(10001): 000
middleThreeDigits(-10001): 000
middleThreeDigits(-123): 123
middleThreeDigits(-100): 100
middleThreeDigits(100): 100
middleThreeDigits(-12345): 234
middleThreeDigits(-9223372036854775808): 368
middleThreeDigits(9223372036854775807): 368
middleThreeDigits(1): Need odd and >= 3 digits
middleThreeDigits(2): Need odd and >= 3 digits
middleThreeDigits(-1): Need odd and >= 3 digits
middleThreeDigits(-10): Need odd and >= 3 digits
middleThreeDigits(2002): Need odd and >= 3 digits
middleThreeDigits(-2002): Need odd and >= 3 digits
middleThreeDigits(0): Need odd and >= 3 digits
middleThreeDigits(-2147483648): Need odd and >= 3 digits
middleThreeDigits(2147483647): Need odd and >= 3 digits

JavaScript

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)}
});

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

Or, using an option type, composing a solution from existing generic primitives, and formatting the output a little: {{Trans|Python}}

(() => {
    '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();
})();

{{Out}}

      123 -> 123
    12345 -> 234
  1234567 -> 345
987654321 -> 654
    10001 -> 000
   -10001 -> 000
     -123 -> 123
     -100 -> 100
      100 -> 100
   -12345 -> 234
        1 -> (Less than 3 digits)
        2 -> (Less than 3 digits)
       -1 -> (Less than 3 digits)
      -10 -> (Less than 3 digits)
     2002 -> (Even digit count)
    -2002 -> (Even digit count)
        0 -> (Less than 3 digits)

jq

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 )"

Typescript:

 $ 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

Julia

{{works with|Julia|1.0.3}}

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

{{out}}

       123 -> 123
     12345 -> 234
   1234567 -> 345
 987654321 -> 654
     10001 -> 000
    -10001 -> 000
      -123 -> 123
      -100 -> 100
       100 -> 100
    -12345 -> 234
         1 -> n must have 3 digits or more
         2 -> n must have 3 digits or more
        -1 -> n must have 3 digits or more
       -10 -> n must have an odd number of digits
      2002 -> n must have an odd number of digits
     -2002 -> n must have an odd number of digits
         0 -> n must have 3 digits or more

K

/ 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)}

The output of the session: {{out}}

K Console - Enter \ for help

  \l mid3

  mid3' 123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345 1 2 -1 -10
 2002 -2002 0
("123"
 "234"
 "345"
 "654"
 "000"
 "000"
 "123"
 "100"
 "100"
 "234"
 "small"
 "small"
 "small"
 "small"
 "even"
 "even"
 "small")

Klong

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)

Output:

[123 234 345 654 000 000 123 100 100 234 small small small small even even small]

Kotlin

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
}

Lasso

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)

}
'
```txt
'
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 />'
^}
'

'

'''Output'''

```txt
            123: 123
          12345: 234
        1234567: 345
      987654321: 654
          10001: 000
         -10001: 000
           -123: 123
           -100: 100
            100: 100
         -12345: 234
              1: Error: too few digits
              2: Error: too few digits
             -1: Error: too few digits
            -10: Error: too few digits
           2002: Error: even number of digits
          -2002: Error: even number of digits
              0: Error: too few digits

Logo

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

{{Output}}

123:	 	123
12345:	 	234
1234567:	345
987654321:	654
10001:	 	000
-10001:	 	000
-123:	 	123
-100:	 	100
100:	 	100
-12345:	 	234
1:	 	Number must have at least 3 digits
2:	 	Number must have at least 3 digits
-1:	 	Number must have at least 3 digits
-10:	 	Number must have at least 3 digits
2002:	 	Number must have odd number of digits
-2002:	 	Number must have odd number of digits
0:	 	Number must have at least 3 digits

Lua

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

{{out}}

123	123
12345	234
1234567	345
987654321	654
10001	000
-10001	000
-123	123
-100	100
100	100
-12345	234
1	Error: the number has less than 3 digits.
2	Error: the number has less than 3 digits.
-1	Error: the number has less than 3 digits.
-10	Error: the number is even.
2002	Error: the number is even.
-2002	Error: the number is even.
0	Error: the number has less than 3 digits.

Maple

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;

{{out}}

      123: 123
    12345: 234
  1234567: 345
987654321: 654
    10001: 000
   -10001: 000
     -123: 123
     -100: 100
      100: 100
   -12345: 234
        1: Error: Not enough digits.
        2: Error: Not enough digits.
       -1: Error: Not enough digits.
      -10: Error: Not enough digits.
     2002: Error: Even number of digits.
    -2002: Error: Even number of digits.
        0: Error: Not enough digits.

Mathematica

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]

{{out}}

123
234
345
654
000
000
123
100
100
234
err: n too small
err: n too small
err: n too small
err: n too small
err: even number of digits
err: even number of digits
err: n too small

=={{header|MATLAB}} / {{header|Octave}}==

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]);

Test with

 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;

Result

      123:123
    12345:234
  1234567:457
987654321:654
    10001:000
   -10001:000
     -123:123
     -100:100
      100:100
   -12345:234
        1:*** error: number of digits must not be smaller than 3 ***
        2:*** error: number of digits must not be smaller than 3 ***
       -1:*** error: number of digits must not be smaller than 3 ***
      -10:*** error: number of digits must be odd ***
     2002:*** error: number of digits must be odd ***
    -2002:*** error: number of digits must be odd ***
        0:*** error: number of digits must not be smaller than 3 ***

MiniScript

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

{{out}}

123 --> 123
12345 --> 234
1234567 --> 345
987654321 --> 654
10001 --> 000
-10001 --> 000
-123 --> 123
-100 --> 100
100 --> 100
-12345 --> 234
1 --> Input too short
2 --> Input too short
-1 --> Input too short
-10 --> Input too short
2002 --> Input length not odd
-2002 --> Input length not odd
0 --> Input too short

=={{header|MK-61/52}}== П0 lg [x] 3 - x>=0 23 ИП0 1 0 / [x] ^ lg [x] 10^x П1 / {x} ИП1

• БП 00 1 + x=0 29 ИП0 С/П 0 /

''Instruction:'' enter the number in the РX (on display), the result after the execution of the same. In the case of an even or less than 3 number of digits the indicator displays an error message.


## ML

=
## mLite
=

```ocaml

	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;

Output:

123 --> 123
12345 --> 234
1234567 --> 345
987654321 --> 654
10001 --> 000
~10001 --> 000
~123 --> 123
~100 --> 100
100 --> 100
~12345 --> 234
1 --> too small
2 --> too small
~1 --> too small
~10 --> too small
2002 --> has even digits
~2002 --> has even digits
0 --> too small

MUMPS

This sample shows the MUMPS code required to pass the specification.

/* 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)

'''Output:'''

       123: 123
     12345: 234
   1234567: 345
 987654321: 654
     10001: 000
    -10001: 000
      -123: 123
      -100: 100
       100: 100
    -12345: 234
         1: NUMBER TOO SMALL
         2: NUMBER TOO SMALL
        -1: NUMBER TOO SMALL
       -10: NUMBER TOO SMALL
      2002: EVEN NUMBER OF DIGITS
     -2002: EVEN NUMBER OF DIGITS
         0: NUMBER TOO SMALL

NetRexx

This sample goes the extra mile and provides a method that can display the middle N digits from the input value. To satisfy the requirements of this task, a static invocation of this general method is also provided with the value '''3''' hard coded as the digit count.

/* 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

'''Output:'''

Middle 3 characters
            123: 123
          12345: 234
        1234567: 345
      987654321: 654
          10001: 000
         -10001: 000
           -123: 123
           -100: 100
            100: 100
         -12345: 234
              1: has less than 3 digits
              2: has less than 3 digits
             -1: has less than 3 digits
            -10: has less than 3 digits
           2002: does not have an odd number of digits
          -2002: does not have an odd number of digits
              0: has less than 3 digits
            abc: is not a whole number
            1e3: is not a whole number
         -17e-3: is not a whole number
         4004.5: is not a whole number
       12345678: does not have an odd number of digits
     9876543210: does not have an odd number of digits

NewLISP

(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)

'''Output:'''

The middle 3 digits of 123 are 123.
The middle 3 digits of 12345 are 234.
The middle 3 digits of 1234567 are 345.
The middle 3 digits of 987654321 are 654.
The middle 3 digits of 10001 are 000.
The middle 3 digits of -10001 are 000.
The middle 3 digits of -123 are 123.
The middle 3 digits of -100 are 100.
The middle 3 digits of 100 are 100.
The middle 3 digits of -12345 are 234.
You entered 1. Sorry, but I need 3 or more digits.
You entered 2. Sorry, but I need 3 or more digits.
You entered -1. Sorry, but I need 3 or more digits.
You entered 10. I need an odd number of digits, not 2.
You entered 2002. I need an odd number of digits, not 4.
You entered -2002. I need an odd number of digits, not 4.
You entered 0. Sorry, but I need 3 or more digits.

Nim

import math

proc middleThreeDigits(i): auto =
  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

Output:

middleThreeDigits(123) returned: 123
middleThreeDigits(12345) returned: 234
middleThreeDigits(1234567) returned: 345
middleThreeDigits(987654321) returned: 654
middleThreeDigits(10001) returned: 000
middleThreeDigits(-10001) returned: 000
middleThreeDigits(-123) returned: 123
middleThreeDigits(-100) returned: 100
middleThreeDigits(100) returned: 100
middleThreeDigits(-12345) returned: 234
middleThreeDigits(1) returned: Need odd and >= 3 digits
middleThreeDigits(2) returned: Need odd and >= 3 digits
middleThreeDigits(-1) returned: Need odd and >= 3 digits
middleThreeDigits(-10) returned: Need odd and >= 3 digits
middleThreeDigits(2002) returned: Need odd and >= 3 digits
middleThreeDigits(-2002) returned: Need odd and >= 3 digits
middleThreeDigits(0) returned: Need odd and >= 3 digits

Objeck

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));
    };
  }

}

123: 123
12345: 234
1234567: 345
987654321: 654
10001: 000
-10001: 000
-123: 123
-100: 100
100: 100
-12345: 234
1: Error
2: Error
-1: Error
-10: Error
2002: Error
-2002: Error
0: Error

OCaml

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;
;;

{{out}}

Should pass:
123: 123
12345: 234
1234567: 345
987654321: 654
10001: 000
-10001: 000
-123: 123
-100: 100
100: 100
-12345: 234

Should fail:
1: failure: need >= 3 digits
2: failure: need >= 3 digits
-1: failure: need >= 3 digits
-10: failure: need >= 3 digits
2002: failure: need odd number of digits
-2002: failure: need odd number of digits
0: failure: need >= 3 digits

Oforth

: 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 ;

{{out}}

[ 123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345] map(#middle3) println
[123, 234, 345, 654, 000, 000, 123, 100, 100, 234]

[ 1, 2, -1, -10, 2002, -2002, 0 ] apply(#middle3)
Too short
Too short
Too short
Too short
Not odd number of digits
Not odd number of digits
Too short

PARI/GP

{{works with|PARI/GP|2.6.0}}

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])

Output:

%1 = [123, 234, 345, 654, 0, 0, 123, 100, 100, 234, "no middle 3 digits", "no middle 3 digits", "no middle 3 digits", "no middle 3 digits", "no middle 3 digits", "no middle 3 digits", "no middle 3 digits"]

If for some reason you want to see the leading digits, you can run

apply(n-> Strprintf("%03d", n), %)

For earlier versions digits can be defined as

digits(n)=eval(Vec(Str(n)))

or more efficiently as

digits(n)=Vec(apply(n->n-48,Vectorsmall(Str(n))))

Pascal

{{works with|Free Pascal}}

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.

{{out}}

      123: 123
    12345: 234
  1234567: 345
987654321: 654
    10001: 000
   -10001: 000
     -123: 123
     -100: 100
      100: 100
   -12345: 234
        1: got too few digits
        2: got too few digits
       -1: got too few digits
      -10: got too few digits
     2002: got even number of digits
    -2002: got even number of digits
        0: got too few digits

Perl

#!/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 ;

{{out}}

Middle 3 digits of 123 : 123 !
Middle 3 digits of 12345 : 234 !
Middle 3 digits of 1234567 : 345 !
Middle 3 digits of 987654321 : 654 !
Middle 3 digits of 10001 : 000 !
Middle 3 digits of -10001 : 000 !
Middle 3 digits of -123 : 123 !
Middle 3 digits of -100 : 100 !
Middle 3 digits of 100 : 100 !
Middle 3 digits of -12345 : 234 !
Middle 3 digits can't be shown : 1 too short!
Middle 3 digits can't be shown : 2 too short!
Middle 3 digits can't be shown : -1 too short!
Middle 3 digits can't be shown : -10 too short!
Middle 3 digits can't be shown : even number of digits in 2002!
Middle 3 digits can't be shown : even number of digits in -2002!
Middle 3 digits can't be shown : 0 too short!

Perl 6

sub middle-three($n) {
    given $n.abs {
        when .chars < 3  { "$n is too short" }
        when .chars %% 2 { "$n has an even number of digits" }
        default          { "The three middle digits of $n are: ", .substr: (.chars - 3)/2, 3 }
    }
}

say middle-three($_) for <
    123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345
    1 2 -1 -10 2002 -2002 0
>;

{{out}}

The three middle digits of 123 are:  123
The three middle digits of 12345 are:  234
The three middle digits of 1234567 are:  345
The three middle digits of 987654321 are:  654
The three middle digits of 10001 are:  000
The three middle digits of -10001 are:  000
The three middle digits of -123 are:  123
The three middle digits of -100 are:  100
The three middle digits of 100 are:  100
The three middle digits of -12345 are:  234
1 is too short
2 is too short
-1 is too short
-10 is too short
2002 has an even number of digits
-2002 has an even number of digits
0 is too short

It is also possible to write a regular expression with a code assertion:

for [\~] ^10 { say "$_ => $()" if m/^^(\d+) <(\d**3)> (\d+) $$ <?{ $0.chars == $1.chars}> / }

{{out}}

01234 => 123
0123456 => 234
012345678 => 345

Phix

procedure mid3(integer i)
    string s = sprintf("%d",abs(i))
    integer k = length(s)-3
    printf(1,"%10d: %s\n",{i,iff(k<0 or and_bits(k,1)?"error":s[k/2+1..k/2+3])})
end procedure

constant tests = {123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,
                  1,2,-1,-10,2002,-2002,0}
for i=1 to length(tests) do
    mid3(tests[i])
end for

{{out}}

       123: 123
     12345: 234
   1234567: 345
 987654321: 654
     10001: 000
    -10001: 000
      -123: 123
      -100: 100
       100: 100
    -12345: 234
         1: error
         2: error
        -1: error
       -10: error
      2002: error
     -2002: error
         0: error

PHP

// 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). '
';
}

Output:

123 : 123
12345 : 234
1234567 : 345
987654321 : 654
10001 : 000
-10001 : 000
-123 : 123
-100 : 100
100 : 100
-12345 : 234
1 : The value must contain at least three digits...
2 : The value must contain at least three digits...
-1 : The value must contain at least three digits...
-10 : The value must contain at least three digits...
2002 : The value must contain an odd amount of digits...
-2002 : The value must contain an odd amount of digits...
0 : The value must contain at least three digits...

PicoLisp

(de middle3digits (N)
   (let (Lst (chop (abs N))  Len (length Lst))
      (tab (10 -2 -30)
         N
         ":"
         (cond
            ((> 3 Len) "not enough digits")
            ((bit? 1 Len)
               (head 3 (nth Lst (/ Len 2))) )
            (T "even number of digits") ) ) ) )

Test:

(mapc middle3digits
   (123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345
      1 2 -1 -10 2002 -2002 0 ) )

Output:

       123: 123
     12345: 234
   1234567: 345
 987654321: 654
     10001: 000
    -10001: 000
      -123: 123
      -100: 100
       100: 100
    -12345: 234
         1: not enough digits
         2: not enough digits
        -1: not enough digits
       -10: not enough digits
      2002: even number of digits
     -2002: even number of digits
         0: not enough digits

PL/I

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;

Output:

               123      The middle three digits are: 123
             12345      The middle three digits are: 234
           1234567      The middle three digits are: 345
         987654321      The middle three digits are: 654
             10001      The middle three digits are: 000
            -10001      The middle three digits are: 000
              -123      The middle three digits are: 123
              -100      The middle three digits are: 100
               100      The middle three digits are: 100
           -123451      not possible
                 2      not possible
                -1      not possible
               -10      not possible
              2002      not possible
             -2002      not possible
                 0      not possible

PowerShell

function middle3($inp){

	$str = [Math]::abs($inp)

	$leng = "$str".length

	if ($leng -lt 3){
		Write-host $inp":	[ERROR] too short."
		Return
	}
	if (($leng % 2) -eq 0){
		Write-host $inp":	[ERROR] even number of digits."
	} else {
		$trimmer = ($leng - 3) / 2
		$ans = "$str".subString($trimmer,3)

		Write-host $inp":	$ans"
	}
	Return
}

$sample = 123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0

foreach ($x in $sample){middle3 $x}

{{Out}}

123:    123
12345:  234
1234567:        345
987654321:      654
10001:  000
-10001: 000
-123:   123
-100:   100
100:    100
-12345: 234
1:      [ERROR] too short.
2:      [ERROR] too short.
-1:     [ERROR] too short.
-10:    [ERROR] too short.
2002:   [ERROR] even number of digits.
-2002:  [ERROR] even number of digits.
0:      [ERROR] too short.

Prolog

{{works with|SWI-Prolog|6}}

middle_3_digits(Number, [D1,D2,D3]) :-
    verify_middle_3_able(Number, Digits),
    append(FrontDigits, [D1,D2,D3| BackDigits], Digits),
    same_length(FrontDigits, BackDigits).

verify_middle_3_able(Number, Digits) :-
    must_be(number, Number),
    AbsNumber is abs(Number),
    number_chars(AbsNumber, Digits),
    length(Digits, NumDigits),
    ( 3 > NumDigits         ->  domain_error('at least 3 digits',    Number)
    ; 0 is NumDigits mod 2  ->  domain_error('odd number of digits', Number)
    ; true
    ).

Test code:

test_correct :-
    TestCases = [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345],
    foreach( ( member(TestCase, TestCases),
               middle_3_digits(TestCase, Result) ),
            format('Middle 3 digits of ~w ~30|: ~w~n', [TestCase, Result])
          ).

Testing correct inputs:

?- test_correct.
Middle 3 digits of 123        : [1,2,3]
Middle 3 digits of 12345      : [2,3,4]
Middle 3 digits of 1234567    : [3,4,5]
Middle 3 digits of 987654321  : [6,5,4]
Middle 3 digits of 10001      : [0,0,0]
Middle 3 digits of -10001     : [0,0,0]
Middle 3 digits of -123       : [1,2,3]
Middle 3 digits of -100       : [1,0,0]
Middle 3 digits of 100        : [1,0,0]
Middle 3 digits of -12345     : [2,3,4]
true.

Errors

?- middle_3_digits(1, S).
ERROR: Domain error: `at least 3 digits' expected, found `1'
?- middle_3_digits(2, S).
ERROR: Domain error: `at least 3 digits' expected, found `2'
?- middle_3_digits(-1, S).
ERROR: Domain error: `at least 3 digits' expected, found `-1'
?- middle_3_digits(-10, S).
ERROR: Domain error: `at least 3 digits' expected, found `-10'
?- middle_3_digits(2002, S).
ERROR: Domain error: `odd number of digits' expected, found `2002'
?- middle_3_digits(-2002, S).
ERROR: Domain error: `odd number of digits' expected, found `-2002'
?- middle_3_digits(0, S).
ERROR: Domain error: `at least 3 digits' expected, found `0'

Python

Procedural

 def middle_three_digits(i):
	s = str(abs(i))
	length = len(s)
	assert length >= 3 and length % 2 == 1, "Need odd and >= 3 digits"
	mid = length // 2
	return s[mid-1:mid+2]

>>> passing = [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345]
>>> failing = [1, 2, -1, -10, 2002, -2002, 0]
>>> for x in passing + failing:
	try:
		answer = middle_three_digits(x)
	except AssertionError as error:
		answer = error
	print("middle_three_digits(%s) returned: %r" % (x, answer))


middle_three_digits(123) returned: '123'
middle_three_digits(12345) returned: '234'
middle_three_digits(1234567) returned: '345'
middle_three_digits(987654321) returned: '654'
middle_three_digits(10001) returned: '000'
middle_three_digits(-10001) returned: '000'
middle_three_digits(-123) returned: '123'
middle_three_digits(-100) returned: '100'
middle_three_digits(100) returned: '100'
middle_three_digits(-12345) returned: '234'
middle_three_digits(1) returned: AssertionError('Need odd and >= 3 digits',)
middle_three_digits(2) returned: AssertionError('Need odd and >= 3 digits',)
middle_three_digits(-1) returned: AssertionError('Need odd and >= 3 digits',)
middle_three_digits(-10) returned: AssertionError('Need odd and >= 3 digits',)
middle_three_digits(2002) returned: AssertionError('Need odd and >= 3 digits',)
middle_three_digits(-2002) returned: AssertionError('Need odd and >= 3 digits',)
middle_three_digits(0) returned: AssertionError('Need odd and >= 3 digits',)
>>>

Composition of pure functions

Using a composable option type as an alternative to error handling: {{Trans|Haskell}}

'''Middle 3 digits'''


# mid3digits :: Int -> Either String String
def mid3digits(n):
    '''Either the middle three digits,
       or an explanatory string.'''
    m = abs(n)
    s = str(m)
    return Left('Less than 3 digits') if (100 > m) else (
        Left('Even digit count') if even(len(s)) else Right(
            s[(len(s) - 3) // 2:][0:3]
        )
    )


# TEST ----------------------------------------------------
def main():
    '''Test'''

    def bracketed(x):
        return '(' + str(x) + ')'

    print(
        tabulated('Middle three digits, where defined:\n')(str)(
            either(bracketed)(str)
        )(mid3digits)([
            123, 12345, 1234567, 987654321, 10001, -10001, -123,
            -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0
        ])
    )


# GENERIC -------------------------------------------------

# Left :: a -> Either a b
def Left(x):
    '''Constructor for an empty Either (option type) value
       with an associated string.'''
    return {'type': 'Either', 'Right': None, 'Left': x}


# Right :: b -> Either a b
def Right(x):
    '''Constructor for a populated Either (option type) value'''
    return {'type': 'Either', 'Left': None, 'Right': x}


# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
def compose(g):
    '''Function composition.'''
    return lambda f: lambda x: g(f(x))


# either :: (a -> c) -> (b -> c) -> Either a b -> c
def either(fl):
    '''The application of fl to e if e is a Left value,
       or the application of fr to e if e is a Right value.'''
    return lambda fr: lambda e: fl(e['Left']) if (
        None is e['Right']
    ) else fr(e['Right'])


# even :: Int -> Bool
def even(x):
    '''Is x even ?'''
    return 0 == x % 2


# tabulated :: String -> (b -> String) -> (a -> b) -> [a] -> String
def tabulated(s):
    '''Heading -> x display function -> fx display function ->
                f -> value list -> tabular string.'''
    def go(xShow, fxShow, f, xs):
        w = max(map(compose(len)(str), xs))
        return s + '\n' + '\n'.join(
            xShow(x).rjust(w, ' ') + ' -> ' + fxShow(f(x)) for x in xs
        )
    return lambda xShow: lambda fxShow: lambda f: lambda xs: go(
        xShow, fxShow, f, xs
    )


if __name__ == '__main__':
    main()