ISBN13 check digit: Difference between revisions

{{trans|Python}}

 

n = n.replace(‘-’, ‘’).replace(‘ ’, ‘’)

I n.len != 13

 

L(t) tests

 

{{out}}

=={{header|8080 Assembly}}==

 

jmp demo

;;; ---------------------------------------------------------------

jmp 5

good: db 'good$'

 

{{out}}

=={{header|8086 Assembly}}==

 

bits 16

org 100h

section .data

good: db 'good$'

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

BYTE FUNC CheckISBN13(CHAR ARRAY t)

Test("978-1788399081")

Test("978-1788399083")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/ISBN13_check_digit.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

 

procedure ISBN_Check is

Show ("978-1788399081");

Show ("978-1788399083");

{{out}}

<pre>978-1734314502 Good

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

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

# returns TRUE if the alledged isbn13 has the correct check sum, #

# FALSE otherwise #

)

OD

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

13≠⍴n←(⍵∊⎕D)/⍵:0

0=10|(⍎¨n)+.×13⍴1 3

 

{{out}}

===Composition of pure functions===

 

 

-- isISBN13 :: String -> Bool

return lst

end tell

{{Out}}

<pre>{{"978-1734314502", true}, {"978-1734314509", false}, {"978-1788399081", true}, {"978-1788399083", false}}</pre>

This task ''can'' be tackled very simply by working through the numeric text two characters at a time:

 

if (ISBN13's class is not text) then return false

set output to output as text

set AppleScript's text item delimiters to astid

 

{{output}}

Or it can be handled purely numerically. Since the "weights" alternate and are palindromic, it makes no difference whether the last digit or the first is treated as the check digit. In fact, if preferred, the repeat below can go round 7 times with the <tt>return</tt> line as simply: <tt>return (sum mod 10 = 0)</tt>.

 

if (ISBN13's class is not text) then return false

return ((sum + ISBN13) mod 10 = 0)

 

=={{header|Arturo}}==

 

currentCheck: to :integer to :string last isbn

isbn: map split chop replace isbn "-" "" 'd -> to :integer d

loop tests 'test [

print [test "=>" validISBN? test]

 

{{out}}

 

=={{header|AutoHotkey}}==

for i, v in StrSplit(RegExReplace(n, "[^0-9]"))

sum += !Mod(i, 2) ? v*3 : v

return n "`t" (Mod(sum, 10) ? "(bad)" : "(good)")

nums := ["978-1734314502","978-1734314509","978-1788399081","978-1788399083"]

for i, n in nums

output .= ISBN13_check_digit(n) "`n"

MsgBox % output

{{out}}

<pre>978-1734314502 (good)

 

=={{header|AWK}}==

# syntax: GAWK -f ISBN13_CHECK_DIGIT.AWK

BEGIN {

return(substr(isbn,13,1) == check_digit ? "OK" : sprintf("NG check digit S/B %d",check_digit))

}

{{out}}

<pre>

 

=={{header|BCPL}}==

 

let checkISBN(s) = valof

show("978-1788399081")

show("978-1788399083")

{{out}}

<pre>978-1734314502: good

 

=={{header|C}}==

 

int check_isbn13(const char *isbn) {

}

return 0;

 

{{out}}

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

{{trans|C}}

 

bool check_isbn13(std::string isbn) {

 

return 0;

{{out}}

<pre>978-1734314502: good

 

=={{header|C sharp}}==

using System.Linq;

 

}

}

{{out}}

<pre>

 

=={{header|CLU}}==

if string$size(s) ~= 14 then return(false) end

if s[4] ~= '-' then return(false) end

end

end

{{out}}

<pre>978-1734314502: good

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

* Author: Jay Moseley

* Date: November 10, 2019

 

END FUNCTION validISBN13.

 

{{out}}

 

=={{header|Cowgol}}==

sub check_isbn13(isbn: [uint8]): (r: uint8) is

print(result[check_isbn13(isbns[n])]);

n := n + 1;

{{out}}

<pre>978-1734314502: good

=={{header|D}}==

{{trans|Kotlin}}

 

bool isValidISBN13(string text) {

assert(isValidISBN13("978-1788399081"));

assert(!isValidISBN13("978-1788399083"));

 

=={{header|Draco}}==

byte n, check, d;

char cur;

test("978-1788399081");

test("978-1788399083")

{{out}}

<pre>978-1734314502: good

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(s,

LET(

)

)

 

and also assuming the following generic bindings in the Name Manager for the WorkBook:

 

=LAMBDA(s,

MID(s,

AND(47 < ic, 58 > ic)

)

 

{{Out}}

 

=={{header|Factor}}==

math.functions math.parser math.vectors qw sequences

sequences.extras sets unicode ;

 

qw{ 978-1734314502 978-1734314509 978-1788399081 978-1788399083 }

{{out}}

<pre>

=={{header|Forth}}==

The following word not only identifies correct 13 digit ISBN (and EAN) codes, but also 8 digit EAN and GTIN codes.

 

: isbn? ( a n -- f)

if [char] 0 - * rot + swap 3 * 8 mod else drop drop then

-1 chars +loop drop 10 mod 0= \ now calculate checksum

{{out}}

In Forth, a "true" value is indicated by "-1".

 

=={{header|Fortran}}==

program isbn13

implicit none

end function check_isbn13

end program isbn13

 

{{out}}

 

=={{header|FreeBASIC}}==

 

function is_num( byval c as string ) as boolean

print isbns(i)+": bad"

end if

 

{{out}}

 

=={{header|F_Sharp|F#}}==

open System

 

else

printfn "%s Invalid ISBN13" argv.[0]

 

{{out}}

 

=={{header|Go}}==

 

import (

fmt.Printf("%s: %s\n", isbn, res)

}

 

{{out}}

 

=={{header|Haskell}}==

import Text.Printf (printf)

 

"978-1788399081",

"978-1788399083"

{{out}}

<pre>978-1734314502: Valid: True

Or, expressed in terms of ''cycle'':

 

 

isISBN13 :: String -> Bool

"978-1788399081",

"978-1788399083"

{{Out}}

<pre>("978-1734314502",True)

 

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

110 DO

120 PRINT :INPUT PROMPT "ISBN-13 code: ":IS$

330 LET SUM=SUM+VAL(ISBN$(13))

340 IF MOD(SUM,10)=0 THEN LET ISBN=-1

 

=={{header|J}}==

isbn13c =: D&([ check@:i. clean)

lc =: [ +/@:* weight

weight =: 1 3 $~ #

{{out}}

 

 

=={{header|Java}}==

System.out.println(isISBN13("978-1734314502"));

System.out.println(isISBN13("978-1734314509"));

return false;

}

<pre>

true

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

def isbn_check:

def digits: tostring | explode | map( select(. >= 48 and . <= 57) | [.] | implode | tonumber);

testingcodes[]

| "\(.): \(if isbn_check then "good" else "bad" end)"

{{out}}

<pre>

 

=={{header|Julia}}==

return sum(iseven(i) ? 3 * parse(Int, ch) : parse(Int, ch)

for (i, ch) in enumerate(replace(str, r"\D" => ""))) % 10 == 0

println(code, ": ", isbncheck(code) ? "good" : "bad")

end

<pre>

978-1734314502: good

 

=={{header|Kotlin}}==

fun isValidISBN13(text: String): Boolean {

val isbn = text.replace(Regex("[- ]"), "")

.sum() % 10 == 0

}

 

Tested using Spek

describe("ISBN Utilities") {

mapOf(

}

}

{{out}}

<pre>

{{works with|langur|0.8.11}}

In this example, we map to multiple functions (actually 1 no-op).

.s = replace(.s, RE/[\- ]/)

matching(re/^[0-9]{13}$/, .s) and

write .key, ": ", if(.pass: "good"; "bad")

writeln if(.pass == .tests[.key]: ""; " (ISBN-13 CHECK DIGIT TEST FAILED)")

 

{{works with|langur|0.9.0}}

In this example, we set a for loop value as it progresses.

.s = replace(.s, RE/[\- ]/)

var .alt = true

write .key, ": ", if(.pass: "good"; "bad")

writeln if(.pass == .tests[.key]: ""; " (ISBN-13 CHECK DIGIT TEST FAILED)")

 

{{out}}

=={{header|Lua}}==

{{trans|C}}

local count = 0

local sum = 0

end

 

{{out}}

<pre>978-1734314502: good

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

ValidISBNQ[iban_String] := Module[{i},

i = StringReplace[iban, {" " -> "", "-" -> ""}];

ValidISBNQ["978-1734314509"]

ValidISBNQ["978-1788399081"]

{{out}}

<pre>True

 

=={{header|Modula-2}}==

FROM InOut IMPORT WriteString, WriteLn;

FROM Strings IMPORT Length;

check('978-1788399081');

check('978-1788399083');

{{out}}

<pre>978-1734314502: good

=={{header|Nanoquery}}==

{{trans|Go}}

// remove any hyphens or spaces

isbn = str(isbn).replace("-","").replace(" ","")

 

print format("%s: %s\n", isbn, res)

{{out}}

<pre>978-1734314502: good

 

=={{header|Nim}}==

 

func is_isbn*(s: string): bool =

for isbn in isbns:

var quality: string = if is_isbn(isbn): "good" else: "bad"

{{out}}

<pre>

=={{header|Pascal}}==

{{works with|Extended Pascal}}

 

const

writeLn(isValidISBNString('978-1788399081'));

writeLn(isValidISBNString('978-1788399083'))

{{out}}

<pre>True

 

=={{header|Perl}}==

use warnings;

use feature 'say';

my $check_d = check_digit($isbn);

say "$_ : " . ($check == $check_d ? 'Good' : "Bad check-digit $check; should be $check_d")

{{out}}

<pre>978-1734314502 : Good

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">check_isbn13</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">isbn</span><span style="color: #0000FF;">)</span>

<span style="color: #008000;">"978-2-74839-908-0"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"978-2-74839-908-5"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"978 1 86197 876 9"</span><span style="color: #0000FF;">}</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">isbns</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> <span style="color: #000000;">check_isbn13</span><span style="color: #0000FF;">(</span><span style="color: #000000;">isbns</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|PicoLisp}}==

(let L

(make

"978-1-86197-876-9"

"978-2-74839-908-5"

{{out}}

<pre>

 

=={{header|PL/M}}==

 

CHECK$ISBN13: PROCEDURE (PTR) BYTE;

 

CALL BDOS(0,0);

{{out}}

<pre>978-1734314502: GOOD

 

=={{header|PowerShell}}==

function Get-ISBN13 {

$codes = (

}

Get-ISBN13

 

{{out}}

 

=={{header|PureBasic}}==

Print(X)

If IsISBN13(X) : PrintN(" good") : Else : PrintN(" bad") : EndIf

TestISBN13("978-1788399083")

Input()

{{out}}

<pre>978-1734314502 good

 

=={{header|Python}}==

n = n.replace('-','').replace(' ', '')

if len(n) != 13:

978-1788399083'''.strip().split()

for t in tests:

 

{{out}}

 

Or, expressed in terms of ''itertools.cycle''

 

 

if __name__ == '__main__':

main()

{{Out}}

<pre>('978-1734314502', True)

 

=={{header|Quackery}}==

 

[ 1 & ] is odd? ( n --> b )

$ '978-1734314509' isbn-test

$ '978-1788399081' isbn-test

{{out}}

<pre>

=={{header|Racket}}==

 

 

(define (isbn13-check-digit-valid? s)

(check-false (isbn13-check-digit-valid? "978-1734314509"))

(check-true (isbn13-check-digit-valid? "978-1788399081"))

 

{{out}}

Also test a value that has a zero check digit.

 

(10 - (sum (|$isbn.comb(/<[0..9]>/)) »*» (1,3)) % 10).substr: *-1

}

978-2-74839-908-0

978-2-74839-908-5

{{out}}

<pre>978-1734314502 : Good

=={{header|Red}}==

 

is_digit: charset [#"0" - #"9"]

remove-each i str [not pick is_digit i] ; remove non-digits

print check_valid_isbn13 str

]

 

{{out}}

=={{header|REXX}}==

A couple of additional checks were made to verify a correct length, &nbsp; and also that the ISBN-13 code is all numerics &nbsp; (with optional minus signs).

parse arg $ /*obtain optional arguments from the CL*/

if $='' | if $="," then $= '978-1734314502 978-1734314509 978-1788399081 978-1788399083'

if right(sum, 1)==0 then say ' ISBN-13 code ' x " is valid."

else say ' ISBN-13 code ' x " isn't valid."

{{out|output|text=&nbsp; when using the four default inputs:}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

ok

next

Output:

<pre>

 

=={{header|Ruby}}==

cleaned = str.delete("^0-9").chars

return false unless cleaned.size == 13

isbns = ["978-1734314502", "978-1734314509", "978-1788399081", "978-1788399083"]

isbns.each{|isbn| puts "#{isbn}: #{validISBN13?(isbn)}" }

<pre>978-1734314502: true

978-1734314509: false

 

=={{header|Rust}}==

let isbns = ["978-1734314502", "978-1734314509", "978-1788399081", "978-1788399083"];

isbns.iter().for_each(|isbn| println!("{}: {}", isbn, check_isbn(isbn)));

checksum % 10 == 0

}

{{out}}

<pre>

 

=={{header|Seed7}}==

 

const func boolean: isISBN13 (in var string: input) is func

writeln(str <& ": " <& isISBN13(str));

end for;

{{out}}

<pre>

 

=={{header|Standard ML}}==

fun check (c, p as (m, n)) =

if Char.isDigit c then

val () = (print

o concat

{{out}}

<pre>978-1734314502: good

=={{header|Swift}}==

 

guard !isbn.isEmpty else {

return false

for isbn in cases {

print("\(isbn) => \(checkISBN(isbn: isbn) ? "good" : "bad")")

 

 

=={{header|Tcl}}==

 

proc validISBN13 code {

regsub -all {\D} $code "" code ;# remove non-digits

978-1788399083

} {puts $test:[validISBN13 $test]}

{{out}}

<pre>978-1734314502:true

978-1788399083:false</pre>

Simpler variant, using two loop vars and constant factors; same output:

proc validISBN13 code {

regsub -all {\D} $code "" code ;# remove non-digits

return false

}

 

=={{header|uBasic/4tH}}==

{{works with|version 3.64.0}}

Print Show(a), Show (Iif (Func(_IsISBN (a)), "good", "bad"))

 

Next

 

{{out}}

<pre>978-1734314502 good

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

{{works with|Bourne Again Shell}}

local i n t

n=${1//[^0-9]/}

printf '%s\n' 'NOT OK'

fi

{{Out}}

<pre>978-1734314502: OK

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function CheckISBN13(code As String) As Boolean

End Sub

 

{{out}}

<pre>True

=={{header|Vlang}}==

{{trans|go}}

// remove any hyphens or spaces

isbn := isbn13.replace('-','').replace(' ','')

println("$isbn: $res")

}

 

{{out}}

 

=={{header|Wren}}==

var cps = s.codePoints

var digits = []

for (test in tests) {

System.print("%(test) -> %(isbn13.call(test) ? "good" : "bad")")

 

{{out}}

 

=={{header|XPL0}}==

 

proc ISBN13(Str); \Show if International Standard Book Number is good

ISBN13("978-1-59327-220-3");

ISBN13("978-178839918");

 

{{out}}

 

=={{header|zkl}}==

var [const] one3=("13"*6 + 1).split("").apply("toInt"); // examine 13 digits

// one3=("13"*6) if you want to calculate what the check digit should be

one3.zipWith('*,isbn - " -").sum(0) % 10 == 0

#<<<"

978-1734314502

#<<<

foreach isbn in (isbns)

{{out}}

<pre>