Middle three digits: Difference between revisions

 

;Task:

 

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:

Show your output on this page.

<br><br>

 

=={{header|Ada}}==

 

 

procedure Middle_Three_Digits is

end loop;

 

 

{{out}}

 

=={{header|Aime}}==

m3(integer i)

{

 

s = itoa(i);

s = delete(s, 0);

}

 

v_integer(i);

v_text(" has not enough digits\n");

} else {

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

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

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

)

,

( STRING error message ): # got an error message #

printf( ( $ 11z-d, " : ", n( UPB error message )a $

, test values[ test number ]

)

)

ESAC;

print( ( newline ) )

OD

{{out}}

<pre>

0 : number must have at least three digits

</pre>

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

 

Press any key to continue...</pre>

 

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

 

Press any key to continue . . .</pre>

 

=={{header|Befunge}}==

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

Error, 0 is too short.

The middle three digits of 1234567890 are 456.

</pre>

 

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

 

std::string middleThreeDigits(int n)

}

}

{{out}}

<pre>middleThreeDigits(123): 123

middleThreeDigits(-2002): even number of digits

middleThreeDigits(0): less than three digits</pre>

 

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

 

middleThreeDigits(cast(short)-32768): 276</pre>

 

=={{header|DCL}}==

$ i = 0

$ loop:

$ endif

$ i = i + 1

{{out}}

<pre>$ @middle_three_digits

-2002: has no middle three

0: has no middle three</pre>

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

The middle three digits of 0 are: Not enough digits.

 

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

-2002 ?EVEN

0 ?ONLY 1 DIGITS

</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|Go}}==

 

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:

PASS

ok m3 0.008s

</pre>

 

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

 

 

main :: IO ()

Output:

 

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

-2002: Invalid length 4

0: Invalid length 1</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}}==

 

 

for n = [123, 12345, 1234567, 987654321, 10001, -10001, -123,

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

 

 

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

}

}

 

 

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

0:*** error: number of digits must not be smaller than 3 ***

</pre>

 

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

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)

<pre>middleThreeDigits(123) returned: 123

middleThreeDigits(12345) returned: 234

 

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

0: got too few digits

</pre>

=={{header|Perl}}==

use strict ;

use warnings ;

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

map { middlethree( $_ ) } @numbers ;

{{out}}

<pre>Middle 3 digits of 123 : 123 !

</pre>

 

{{out}}

 

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

-2002 not possible

0 not possible

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

-2002: [ERROR] even number of digits.

0: [ERROR] too short.</pre>

 

=={{header|Prolog}}==

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

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',)

 

=={{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|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>So is the value of a &nbsp; '''googol''' &nbsp; and a &nbsp;'''googolplex'''.

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

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

middle_three_digits(-2002) returned: Failure, Even number of digits

middle_three_digits(0) returned: Failure, Too short</pre>

 

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

-2002: error

0: error

</pre>

 

=={{header|Sidef}}==

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>

| Error! | 0 |

</pre>

 

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

-2002: -2002 has an even number of digits

0: 0 has less than 3 digits</pre>

 

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

(mid3 0)

=> nil</pre>

 

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