Middle three digits: Difference between revisions

{{trans|Python}}

 

V s = String(abs(i))

assert(s.len >= 3 & s.len % 2 == 1, ‘Need odd and >= 3 digits’)

print(‘middle_three_digits(#.) returned: #.’.format(x, answer))

X.catch AssertionError error

 

{{out}}

middle_three_digits(-2002) returned error: Need odd and >= 3 digits

middle_three_digits(0) returned error: Need odd and >= 3 digits

</pre>

 

=={{header|Ada}}==

 

 

procedure Middle_Three_Digits is

end loop;

 

 

{{out}}

 

=={{header|Aime}}==

m3(integer i)

{

 

return 0;

{{out}}

<pre> 123: 123

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.6.win32}}

# return either an integer on success or a error message if #

# the middle 3 digits couldn't be extracted #

print( ( newline ) )

OD

{{out}}

<pre>

 

=={{header|ALGOL W}}==

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

end for_n

 

{{out}}

<pre>

-2002: Number must have an odd number of digits

0: Number must have at least 3 digits

</pre>

 

987654321 is too large to be represented as an AppleScript integer, so "integer value" is taken here to refer to the numeric value rather than to the language class. AppleScript automatically coerces numeric text and single-item lists to appropriate number classes where necessary and possible, so these are acceptable as parameters too.

 

try

n as number -- Errors if n isn't a number or coercible thereto.

set output to output as text

set AppleScript's text item delimiters to astid

 

{{output}}

The middle three digits of 12345 are 234.

The middle three digits of 1234567 are 345.

middle3Digits handler got an error: 2002 has an even number of digits.

middle3Digits handler got an error: -2002 has an even number of digits.

 

===Functional===

 

-- mid3digits :: Int -> Either String String

end tell

end if

{{Out}}

<pre>Mid three digits:

=={{header|Arturo}}==

 

n: to :string abs num

if 3 > size n -> return "Number must have at least three digits"

loop samples 's [

print [pad to :string s 10 ":" middleThree s]

 

{{out}}

 

=={{header|ATS}}==

(* ****** ****** *)

//

 

(* ****** ****** *)

{{out}}

<pre>Middle-three-digits(123): 123

 

=={{header|AutoHotkey}}==

Loop, parse, Numbers, `,

{

log := log . A_LoopField . "`t: " . SubStr(n,((d-3)//2)+1,3) . "`n"

}

{{out}}

<pre>123 : 123

 

=={{header|AWK}}==

# use as: awk -f middle_three_digits.awk

 

}

}

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

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

300 DATA123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345

310 DATA1,2,-1,-10,2002,-2002,0

{{out}}

<pre>

0: ?ONLY 1 DIGIT

</pre>

 

==={{header|BBC BASIC}}===

FOR i% = 1 TO 17

READ test%

OTHERWISE

= MID$(n$, LEN n$ / 2, 3)

{{out}}

<pre> 123 -> 123

 

==={{header|FBSL}}===

 

DIM numbers AS STRING = "123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345,1,2,-1,-10,2002,-2002,0"

RETURN m

END IF

Output

<pre> 123 --> 123

 

==={{header|IS-BASIC}}===

120 PRINT MIDDLE$(N)

130 DEF MIDDLE$(N)

170 LET P=(LEN(N$)-3)/2

180 LET MIDDLE$=N$(P+1:P+3)

 

 

==={{header|PureBasic}}===

Protected x$, digitCount

 

Print(#crlf$ + #crlf$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre> 123 : 123

 

==={{header|Run BASIC}}===

 

while word$(x$,i+1,",") <> ""

end if

wend

<pre>123 123

234 12345

-2002 length < 3 or is even

0 length < 3 or is even</pre>

 

=={{header|Batch File}}==

setlocal enabledelayedexpansion

 

)

goto :EOF

{{Out}}

<pre>123: 123

Reads the integer value from stdin and writes the middle three digits (or an error message) to stdout.

 

v+*86%+55:p00<

>\55+/:00g1+\|

2^,+55_,#!>#:<

>/>\#<$#-:#1_v

 

{{out}} (multiple runs)

 

=={{header|Bracmat}}==

= x p

. @(!arg:? [?p:? [(1/2*!p+-3/2) %?x [(1/2*!p+3/2) ?)

&

);

Output:

<pre>123

=={{header|Burlesque}}==

 

blsq ) {123 12345 1234567 987654321 -10001 -123}{XX{~-}{L[3.>}w!m]\[}m[uN

123

000

123

 

<tt>m]\[</tt> and <tt>uN</tt> are just for displaying it nicely.

=={{header|C}}==

This code is followed by its output.

#include <stdio.h>

#include <stdlib.h>

}

return 0;

 

<pre>

===Alternative Version===

This code has been extensively rewritten. The original was purely interactive and had to be invoked each time from the console. It also did not produce the correct answer.

#include <stdio.h>

#include <stdlib.h>

}

 

{{out}}

 

=={{header|C++}}==

 

std::string middleThreeDigits(int n)

}

}

{{out}}

<pre>middleThreeDigits(123): 123

 

=={{header|C_sharp|C#}}==

 

namespace RosettaCode

}

}

{{out}}

<pre>123:123

 

=={{header|Clojure}}==

(cond

 

 

{{out}}

<pre>

</pre>

 

=={{header|COBOL}}==

program-id. middle3.

environment division.

add 1 to digit-counter

end-perform.

Output

<pre> 123 --> 123

0 --> Number too small</pre>

Optimised version

program-id. middle3.

environment division.

end-if.

 

Output

<pre> 123 --> 123

 

=={{header|Common Lisp}}==

(defun mid3 (n)

(let ((a (abs n))

((evenp hmd) (need "odd number of"))

(t (nbr (mod (truncate a (expt 10 (/ (- hmd 3) 2))) 1000)))))))

 

Test code:

 

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

{{out}}

<pre>123: 123

-2002: Need odd number of digits, not 4.

0: Zero is 1 digit</pre>

 

=={{header|D}}==

 

string middleThreeDigits(T)(in T n) pure nothrow if (isIntegral!T) {

foreach (immutable n; failing)

writefln("middleThreeDigits(%s): %s", n, middleThreeDigits(n));

{{out}}

<pre>middleThreeDigits(123): 123

===Alternative Version===

This longer version gives a stronger typed output, and it tries to be faster avoiding conversions to string.

 

/// Returns a string with the error, or the three digits.

writefln("middleThreeDigits(cast(short)%d): %s", n, mtd);

}

{{out}}

<pre>middleThreeDigits(123): 123

 

=={{header|Dart}}==

import'dart:math';

int length(int x)

}

}

 

=={{header|DCL}}==

$ i = 0

$ loop:

$ endif

$ i = i + 1

{{out}}

<pre>$ @middle_three_digits

=={{header|Delphi}}==

See [https://rosettacode.org/wiki/Middle_three_digits#Pascal Pascal].

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

 

=={{header|Elena}}==

import extensions;

if(len<3)

{

}

else if(len.isEven())

{

};

{

new int[]{123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0}

{

}

{{out}}

<pre>

 

=={{header|Elixir}}==

def three(num) do

n = num |> abs |> to_string

e -> IO.puts e.message

end

 

{{out}}

 

=={{header|Erlang}}==

-module(middle_three_digits).

-export([main/0]).

loop(X,N) when X>0 ->

loop(X-1, N div 10).

{{out}}

<pre>123

 

=={{header|ERRE}}==

PROGRAM MIDDLE

 

END FOR

END PROGRAM

{{out}}

<pre>

 

=={{header|Factor}}==

sequences ;

IN: rosetta-code.middle-three-digits

test-values [ dup "%9d : " printf middle-three ] each ;

 

{{out}}

<pre>

=={{header|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.

abs s>d <# #s #> dup 2/ 0<> over 1 and 0<> and

if 2/ 1- chars + 3 else drop 0 then

 

=={{header|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

 

end program MiddleMuddle

 

=={{header|FreeBASIC}}==

 

Function middleThreeDigits (n As Integer) As String

Print

Print "Press any key to quit"

 

{{out}}

0 => Error: does not have 3 middle digits

</pre>

 

=={{header|Gambas}}==

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

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

Next

 

Output:

<pre>

 

File m3.go:

 

import (

m := len(s) / 2

return s[m-1 : m+2], nil

File m3_test.go:

 

import (

t.Logf("d(%d) returns %q", tc.i, err)

}

{{out}}

Output of go test is normally terse:

 

=={{header|Gosu}}==

valid.each(\ num ->print(middleThree(num)))

 

var start = (s.length / 2) - 1

return s.substring(start, start + 3)

 

{{Output}}

 

=={{header|Groovy}}==

def text = Math.abs(number) as String

assert text.size() >= 3 : "'$number' must be more than 3 numeric digits"

int start = text.size() / 2 - 1

text[start..(start+2)]

Test Code:

def text = (number as String).padLeft(10)

try {

println "$text cannot be converted: $error.message"

}

Output:

<pre> 123: 123

 

=={{header|Haskell}}==

mid3 n

| otherwise = Right . take 3 $ drop ((lng - 3) `div` 2) s

where

lng = length s

 

main :: IO ()

main = do

, 0

]

(putStrLn . unlines) $

(\n ->

xs

Output:

<pre> 123 -> 123

100 -> 100

-12345 -> 234

 

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

The following solution works in both languages.

 

every n := !a do write(right(n,15)," -> ",midM(n))

end

else "wrong number of digits"

else "too short"

 

with output:

 

=={{header|J}}==

'''Solution:'''

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'

'''Example:'''

getMiddle3 vals

123

err

err

 

=={{header|Java}}==

 

public static void main(String[] args) {

return s.substring(mid - 1, mid + 2);

}

<pre>middleThreeDigits(123): 123

middleThreeDigits(12345): 234

 

=={{header|JavaScript}}==

var n=''+Math.abs(x); var l=n.length-1;

if(l<2||l%2) throw new Error(x+': Invalid length '+(l+1));

1, 2, -1, -10, 2002, -2002, 0].forEach(function(n){

try{console.log(n,middleThree(n))}catch(e){console.error(e.message)}

 

<pre>123 "123"

Or, using an option type, composing a solution from existing generic primitives, and formatting the output a little:

{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>

 

=={{header|jq}}==

if . < 0 then -. else . end

| tostring as $s

 

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

123 => 123

12345 => 234

2002 => invalid length: 4

-2002 => invalid length: 4

 

=={{header|Julia}}==

{{works with|Julia|1.0.3}}

 

 

function middle3(n::Integer)

-100, 100, -12345, 1, 2, -1, -10, 2002, -2002, 0]

@printf("%10d -> %s\n", n, try middle3(n) catch e e.msg end)

 

{{out}}

 

=={{header|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}}

 

=={{header|Klingphix}}==

 

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

 

" " input

{{out}}

<pre>123 : 123

 

=={{header|Klong}}==

 

mid3::{[d k];:[3>k::#$#x;"small":|0=k!2;"even";(-d)_(d::_(k%2)-1)_$#x]}

Output:

<pre>[123 234 345 654 000 000 123 100 100 234 small small small small even even small]</pre>

 

=={{header|Kotlin}}==

val s = Math.abs(x).toString()

return when {

println(middleThree(123))// 123

println(middleThree(123555)) //null

 

=={{header|Lambdatalk}}==

{def S 123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345

1 2 -1 -10 2002 -2002 0}

-2002: has an even number of digits

0: has not enough digits

 

=={{header|Lasso}}==

local(

pos_value = math_abs(#value),

'<br />'

^}

'''Output'''

<pre> 123: 123

 

=={{header|Logo}}==

if [less? :n 0] [make "n minus :n]

local "len make "len count :n

]

 

 

{{Output}}

 

=={{header|Lua}}==

if n < 0 then

n = -n

print(n, middle_three(n))

end

 

{{out}}

 

=={{header|Maple}}==

local nList, start;

nList := [seq(parse(i), i in convert (abs(n), string))];

middleDigits(i);

printf("\n");

{{out}}

<pre>

</pre>

 

Block[{digits = IntegerDigits[n], len},

len = Length[digits];

100, -12345, 1, 2, -1, -10, 2002, -2002, 0};

 

234

345

err: even number of digits

err: even number of digits

 

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

% http://rosettacode.org/wiki/Middle_three_digits

 

end;

 

Test with

Result

<pre>

 

=={{header|MiniScript}}==

if num < 0 then num = -num

s = str(num)

100, -12345, 1, 2, -1, -10, 2002, -2002, 0]

print test + " --> " + middle3(test)

{{out}}

<pre>123 --> 123

 

=={{header|МК-61/52}}==

/ [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.

=={{header|ML}}==

==={{header|mLite}}===

val test_array = ["123","12345","1234567","987654321","10001","~10001","~123","~100","100","~12345","1","2","~1","~10","2002","~2002","0"];

;

Output:

<pre>123 --> 123

=={{header|MUMPS}}==

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

MID3(N) ;

N LEN,N2

 

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

<pre>

=={{header|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 '''<tt>3</tt>''' hard coded as the digit count.

options replace format comments java crossref symbols nobinary

 

end

return text

'''Output:'''

<pre>

 

=={{header|NewLISP}}==

(define (middle3 x)

(if (even? (length x))

 

(map middle3 lst)

'''Output:'''

<pre>

 

=={{header|Nim}}==

var s = $abs(i)

if s.len < 3 or s.len mod 2 == 0:

var answer = try: middleThreeDigits(i)

except ValueError: getCurrentExceptionMsg()

 

{{out}}

 

=={{header|Objeck}}==

class Test {

function : Main(args : String[]) ~ Nil {

}

 

 

<pre>

=={{header|OCaml}}==

 

 

let middle_three_digits x =

print_endline "Should fail:";

List.iter print failing;

 

{{out}}

=={{header|Oforth}}==

 

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

 

{{out}}

=={{header|PARI/GP}}==

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

Output:

<pre>%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"]</pre>

 

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

 

For earlier versions <code>digits</code> can be defined as

or more efficiently as

 

=={{header|Pascal}}==

{{works with|Free Pascal}}

{$IFDEF FPC}

{$MODE Delphi} //result /integer => Int32 aka longInt etc..

writeln(n:9,': ',GetMid3dig(Test[i]));

end;

{{out}}

<pre> 123: 123

 

=={{header|Perl}}==

use strict ;

use warnings ;

1, 2, -1, -10, 2002, -2002, 0 ) ;

map { middlethree( $_ ) } @numbers ;

{{out}}

<pre>Middle 3 digits of 123 : 123 !

 

=={{header|Phix}}==

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

{{out}}

<pre>

 

=={{header|PHP}}==

// 64-bit builds of PHP: Integers can be from -9223372036854775808 to 9223372036854775807

 

{

echo $nums.' : '.middlethree($nums). '<br>';

Output:

<pre>123 : 123

-2002 : The value must contain an odd amount of digits...

0 : The value must contain at least three digits...</pre>

 

=={{header|PicoLisp}}==

(let (Lst (chop (abs N)) Len (length Lst))

(tab (10 -2 -30)

((bit? 1 Len)

(head 3 (nth Lst (/ Len 2))) )

Test:

(123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345

Output:

<pre> 123: 123

-2002: even number of digits

0: not enough digits</pre>

 

=={{header|PL/I}}==

middle: procedure options (main); /* 29 October 2013 */

declare n fixed (15);

 

end middle;

Output:

<pre>

 

=={{header|Plain English}}==

Start up.

Test 123.

To test a number:

Get the middle three digits of the number giving a string.

{{out}}

<pre>

 

=={{header|PowerShell}}==

 

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

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

 

{{Out}}

<pre>123: 123

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

 

middle_3_digits(Number, [D1,D2,D3]) :-

verify_middle_3_able(Number, Digits),

; true

).

 

 

Test code:

 

test_correct :-

TestCases = [123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345],

format('Middle 3 digits of ~w ~30|: ~w~n', [TestCase, Result])

).

 

 

=={{header|Python}}==

===Procedural===

s = str(abs(i))

length = len(s)

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

 

 

 

if __name__ == '__main__':

{{Out}}

<pre>Middle three digits, where defined:

=={{header|Quackery}}==

 

 

[ over size -

[ dup number$ 9 justify echo$

say " --> "

 

{{out}}

 

=={{header|Racket}}==

(define (middle x)

(cond

 

(map middle (list 123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345))

The output:

'("error: number too small" "error: number too small" "error: number too small" "error: number too small"

 

=={{header|Raku}}==

(formerly Perl 6)

given $n.abs {

when .chars < 3 { "$n is too short" }

123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345

1 2 -1 -10 2002 -2002 0

{{out}}

<pre>The three middle digits of 123 are: 123

 

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

{{out}}

<pre>01234 => 123

=={{header|REXX}}==

===version 1===

* 03.02.2013 Walter Pachl

* 19.04.2013 mid 3 is now a function returning the middle 3 digits

End

End

Output:

<pre>

<br><br>This REXX version is limited to numbers whose length is &nbsp; <big>≤</big> &nbsp; 100,000 &nbsp; decimal digits.

<br>(The decimal digits limit is defined via the &nbsp; '''numeric digits''' &nbsp; statement in the first line of the subroutine/procedure.)

n= '123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345',

'+123 0123 2 -1 -10 2002 -2002 0 abc 1e3 -17e-3 1234567.',

if L<3 then return er "argument is less than three digits."

if L//2==0 then return er "argument isn't an odd number of digits."

'''output'''

<pre>

 

=={{header|Ring}}==

n = 1234567

middle(n)

but lennr%2=0 see "Number must have an odd number of digits"

else cnr = substr(string(nr),mnr,3) see cnr + nl ok

 

=={{header|Ruby}}==

 

# minus sign doesn't factor into digit count,

# and calling #abs acts as a duck-type assertion

return str[length/2 - 1, 3].to_i

 

Testing program:

 

123, 12345, 1234567, 987654321, 10001, -10001, -123, -100, 100, -12345,

1, 2, -1, -10, 2002, -2002, 0

puts e

end

{{out}}

<pre>

 

=={{header|Rust}}==

let s: String = x.abs().to_string();

let len = s.len();

print_result(*i);

}

 

{{Out}}

course just list the numbers backwards.

</pre>

define m3(i)

{

#endif

1, 2, -1, -10, 2002, -2002, 0 } );

{{out}}<pre>

" 123: 123"

 

=={{header|Scala}}==

* Optionally return the middle three digits of an integer.

*

case Some(v) => "%03d".format(v) // Format the value, force leading zeroes

} mkString("\n")

{{out}}

<pre>123

No middle three

No middle three

</pre>

 

=={{header|Seed7}}==

 

const func string: middle3 (in integer: number) is func

writeln(number <& ": " <& middle3(number));

end for;

 

{{out}}

 

=={{header|SenseTalk}}==

10001, -10001, -123, -100, 100, -12345,

1, 2, -1, -10, 2002, -2002, 0]

 

put output

end repeat

return digits joined by empty

end middle3digits

<pre>

123...........123

=={{header|Sidef}}==

{{trans|Raku}}

if (l < 3) {

"#{n} is too short"

"#{n} has an even number of digits"

} else {

}

}

123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345

1 2 -1 -10 2002 -2002 0

{{out}}

<pre>

 

=={{header|SQL}}==

AS (SELECT CAST(ABS(NUMBER) AS NVARCHAR(MAX)) charNum,

NUMBER,

END Output,

NUMBER Input

 

<pre>

 

=={{header|Swift}}==

if num<0{num = -num}

var numArray:[Int]=[]

i=i/2

print("\(numArray[i+1]),\(numArray[i]),\(numArray[i-1])")

<pre>

123: 123

 

=={{header|Tcl}}==

if {$n < 0} {

set n [expr {-$n}]

set idx [expr {$idx / 2}]

string range $n $idx [expr {$idx+2}]

Demonstrating:

123 12345 1234567 987654321 10001 -10001 -123 -100 100 -12345

1 2 -1 -10 2002 -2002 0

puts "found for ${n}: $mid"

}

{{out}}

<pre>

error for 0: no middle three digits: insufficient digits

</pre>

 

=={{header|UNIX Shell}}==

{{works with|Z Shell}}

 

{

typeset -i n="${1#-}"

printf "%10d: " $n

middle3digits "$n"

 

Output: <pre> 123: 123

=={{header|VBA}}==

 

Option Explicit

 

End If

End Function

{{out}}

<pre>123 Return : 123

 

=={{header|VBScript}}==

 

Function mid3n(n)

WScript.StdOut.Write n & ": " & mid3n(n)

WScript.StdOut.WriteLine

{{Out}}

<pre>

 

=={{header|Vedit macro language}}==

#1 = Get_Num("Enter a number, or 0 to stop: ", STATLINE)

Ins_Text("Input: ") Num_Ins(#1, COUNT, 10)

}

Buf_Quit(OK)

 

Output:

Input: -2002 Result: Not odd number of digits!

Input: 0 Result: Too few digits! </pre>

 

=={{header|Wart}}==

 

withs (digits (with outstring # itoa

(pr abs.n))

mid (int max/2))

if (and odd?.max (max >= 3))

 

'''Output'''

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var middle3 = Fn.new { |n|

 

for (e in a) {

 

{{out}}

 

=={{header|XPL0}}==

 

func Mid3Digits(I); \Return the middle three digits of I

Text(0, Mid3Digits(Passing(X))); CrLf(0);

];

 

{{out}}

 

=={{header|zkl}}==

ns.apply("toString").apply('-("-"))

.apply(fcn(n){nl:=n.len();

}

middle(T(123,12345,1234567,987654321,10001,-10001,-123,-100,100,-12345)).println()

{{out}}

<pre>