Validate International Securities Identification Number: Difference between revisions

{{trans|Python}}

I a.len != 12

R 0B

print([‘US0378331005’, ‘US0373831005’, ‘U50378331005’, ‘US03378331005’,

{{out}}

=={{header|360 Assembly}}==

VALISIN CSECT

USING VALISIN,R13 base register

XDEC DS CL12 temp for xdeco and xdeci

REGEQU

{{out}}

<pre>

Calling the existing Luhn algorithm implementation from the ''[[Luhn test of credit card numbers]]'' task.

-- Luhn_Test copied from other Task

function Luhn_Test (Number: String) return Boolean is

when others =>

Ada.Text_IO.Put_Line("Exception occured");

Output:

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

Uses the LuhnTest procedure from the [[Luhn test of credit card numbers]] task.

% external procedure that returns true if ccNumber passes the Luhn test, false otherwise %

logical procedure LuhnTest ( string(32) value ccNumber

testIsIsin( "AU0000VXGZA3", true );

testIsIsin( "FR0000988040", true );

{{out}}

<pre>

This script calls a handler posted for the [https://www.rosettacode.org/wiki/Luhn_test_of_credit_card_numbers#Straightforward Luhn test of credit card numbers] task.

use framework "Foundation"

set end of testResults to {testNumber:ISIN's contents, valid:ISINTest(ISIN)}

end repeat

{{output}}

=={{header|AWK}}==

# syntax: GAWK -f VALIDATE_INTERNATIONAL_SECURITIES_IDENTIFICATION_NUMBER.AWK

# converted from Fortran

return(v % 10 == 0)

}

{{out}}

<pre>

=={{header|C}}==

int check_isin(char *a) {

}

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

{

using System.Linq;

using System.Text.RegularExpressions;

}

}

{{out}}

<pre>US0378331005 is valid

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

#include <string>

return 0;

}

=={{header|Caché ObjectScript}}==

{

}

{{out|Examples}}

<pre>USER>For { Read isin Quit:isin="" Write ": "_##class(Utils.Check).ISIN(isin), ! }

=={{header|Clojure}}==

(let [sum (->> cc

(map #(Character/digit ^char % 10))

"AU0000XVGZA3" "AU0000VXGZA3" "FR0000988040"]]

(cl-format *out* "~A: ~:[invalid~;valid~]~%" isin (is-valid-isin? isin)))

<tt>luhn?</tt> is based on ''[[Luhn test of credit card numbers#Clojure]]''.

{{out}}

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

*> this is gnucobol 2.0

identification division.

goback

.

{{out}}

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

(char<= #\A char #\Z))

(dolist (isin '("US0378331005" "US0373831005" "U50378331005" "US03378331005"

"AU0000XVGZA3" "AU0000VXGZA3" "FR0000988040"))

{{out}}

<pre>US0378331005: valid

{{trans|Java}}

Code for the luhn test was taken from [[https://rosettacode.org/wiki/Luhn_test_of_credit_card_numbers#D]]

void main() {

import luhn;

return luhnTest(sb.data);

{{out}}

=={{header|Elixir}}==

used Luhn module from [[Luhn_test_of_credit_card_numbers#Elixir | here]]

if str =~ ~r/\A[A-Z]{2}[A-Z0-9]{9}\d\z/ do

String.codepoints(str)

AU0000VXGZA3

FR0000988040)

{{out}}

=={{header|Factor}}==

We re-use the <code>luhn?</code> word from ''[[Luhn test of credit card numbers#Factor]]''.

math math.parser qw sequences strings unicode ;

IN: rosetta-code.isin

] each ;

{{out}}

<pre>

=={{header|Fortran}}==

use ctype

implicit none

check_isin = 0 == mod(v, 10)

end function

=={{header|FreeBASIC}}==

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>US0378331005 Valid

=={{header|Go}}==

import "regexp"

sum += int(n[11] - '0')

return sum%10 == 0

import "testing"

}

}

=={{header|Groovy}}==

{{update|Groovy|Use the new test-cases, and consider calling the existing Luhn algorithm implementation from the ''[[Luhn test of credit card numbers]]'' task instead of duplicating it.}}

int checksum(String prefix) {

assert checksum('GB000263494') == 6

assert checksum('US037833100') == 5

=={{header|Haskell}}==

import Data.Char (isUpper, isDigit, digitToInt)

, "FR0000988040"

]

{{out}}

Or, making alternative choices from the standard libraries:

import Data.Bifunctor (first)

import Data.List (foldl') -- '

"AU0000VXGZA3",

"FR0000988040"

{{Out}}

<pre>("US0378331005",True)

'''Solution:'''

validFmt=: 0 -: '^[A-Z]{2}[A-Z0-9]{9}[0-9]{1}$'&rxindex

luhn=: 0 = 10 (| +/@,) 10 #.inv 1 2 *&|: _2 "."0\ |. NB. as per task Luhn_test_of_credit_card_numbers#J

'''Required Examples:'''

validISIN&> Tests

=={{header|Java}}==

As the Luhn test method from the ''[[Luhn test of credit card numbers]]'' task is only a few lines, it has been embedded in the ISIN class for convenience.

public static void main(String[] args) {

return (s1 + s2) % 10 == 0;

}

<pre>US0378331005 is valid

{{works with|jq}}

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

def luhntest:

def digits: tostring | explode | map([.]|implode|tonumber);

type == "string"

and test("^(?<cc>[A-Z][A-Z])(?<sc>[0-9A-Z]{9})(?<cs>[0-9])$")

'''The Task'''

"US0378331005",

"US0373831005",

| . + " => " + (if is_ISIN then "valid" else "invalid" end);

{{out}}

<pre>

=={{header|Julia}}==

luhntest(x) = luhntest(parse(Int, x))

"US03378331005", "AU0000XVGZA3", "AU0000VXGZA3", "FR0000988040"]

@printf("%-15s %5s\n", inum, ifelse(checkISIN(inum), "pass", "fail"))

{{out}}

=={{header|Kotlin}}==

As the Luhn test method is only a few lines, it's reproduced here for convenience:

object Isin {

println("$isin\t -> ${if (Isin.isValid(isin)) "valid" else "not valid"}")

}

{{out}}

{{works with|langur|0.8.10}}

val .t = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]

val .numbers = s2n .s

write .key, ": ", .pass

writeln if(.pass == .tests[.key]: ""; " (ISIN TEST FAILED)")

{{out}}

=={{header|Lua}}==

local revStr, s1, s2, digit, mod = n:reverse(), 0, 0

for pos = 1, #revStr do

"FR0000988040"

}

{{out}}

<pre>US0378331005 true

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

LuhnQ[n_Integer] := Block[{digits = Reverse@IntegerDigits@n}, Mod[Total[{digits[[;; ;; 2]], IntegerDigits[2 #] & /@ digits[[2 ;; ;; 2]]}, -1], 10] == 0]

VakudISINQ[sin_String] := Module[{s = ToUpperCase[sin]},

]

]

{{out}}

<pre>{True, False, False, False, True, True, True}</pre>

=={{header|Nim}}==

const

echo &"{isin} is valid."

except ISINError:

{{out}}

=={{header|Perl}}==

We reuse the <tt>luhn_test()</tt> function from ''[[Luhn test of credit card numbers#Perl]]''.

use English;

use POSIX;

split(//s, $isin));

return luhn_test($base10);

{{out}}

<pre>1..7

=={{header|Phix}}==

Note this (slightly better) version of Luhn() has the reverse() inside it, whereas the original did not.

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

<span style="color: #008080;">function</span> <span style="color: #000000;">Luhn</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">st</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s : %s\n"</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: #000000;">reasons</span><span style="color: #0000FF;">[</span><span style="color: #000000;">valid_ISIN</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: #000000;">1</span><span style="color: #0000FF;">]})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|PicoLisp}}==

Using the <tt>luhn</tt> function defined at ''[[Luhn test of credit card numbers#PicoLisp]]'':

(let Str (mapcar char (chop Str))

(and

"AU0000XVGZA3"

"AU0000VXGZA3"

{{out}}

<pre>(0 NIL NIL NIL 0 0 0)</pre>

=={{header|PowerShell}}==

function Test-ISIN

{

(10 - ($sum % 10)) % 10 -match $checkDigit

}

"US0378331005","US0373831005","US0337833103","AU0000XVGZA3","AU0000VXGZA3","FR0000988040" | ForEach-Object {

[PSCustomObject]@{

}

}

{{Out}}

<pre>

=={{header|PureBasic}}==

Procedure.b Check_ISIN(*c.Character)

CloseFile(0)

EndIf

{{Out}}

<pre>US0378331005 TRUE

=={{header|Python}}==

if len(a) != 12 or not all(c.isalpha() for c in a[:2]) or not all(c.isalnum() for c in a[2:]):

return False

"AU0000XVGZA3", "AU0000VXGZA3", "FR0000988040"]]

=={{header|Quackery}}==

<code>luhn</code> is defined at [[Luhn test of credit card numbers#Quackery]].

char A char z 1+ within

swap

$ "AU0000VXGZA3" task

$ "FR0000988040" task

{{out}}

=={{header|Racket}}==

#lang racket

(map isin-test? test-cases)

;; -> '(#t #f #f #f #t #t #t)

{{out}}

Using the <tt>luhn-test</tt> function from the ''[[Luhn test of credit card numbers#Raku|Luhn test of credit card numbers]]'' task.

^ <[A..Z]>**2 <[A..Z0..9]>**9 <[0..9]> $

<?{ luhn-test $/.comb.map({ :36($_) }).join }>

AU0000VXGZA3

FR0000988040

{{out}}

=={{header|REXX}}==

parse arg z /*obtain optional ISINs from the C.L.*/

if z='' then z= "US0378331005 US0373831005 U50378331005 US03378331005 AU0000XVGZA3" ,

$= $ + substr(y, j, 1) + left(_, 1) + substr(_, 2 , 1, 0)

end /*j*/ /* [↑] sum the odd and even digits.*/

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

<pre>

=={{header|Ring}}==

# Project : Validate International Securities Identification Number

next

return sumarr

Output:

<pre>

=={{header|Ruby}}==

Using a pre-existing luhn method:

def valid_isin?(str)

FR0000988040).map{|tc| valid_isin?(tc) }

=={{header|Rust}}==

use luhn_cc::compute_luhn;

return compute_luhn(number);

}

=={{header|SAS}}==

length isin $20 ok $1;

input isin;

FR0000988040

;

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/D9ax4Js/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/yOymYqoPSEeA7K7rjgn65g Scastie (remote JVM)].

val isins = Seq("US0378331005", "US0373831005", "U50378331005",

"US03378331005", "AU0000XVGZA3","AU0000VXGZA3", "FR0000988040")

isins.foreach(isin => println(f"$isin is ${if (ISINtest(isin)) "" else "not"}%s valid"))

=={{header|SQL PL}}==

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

RETURN RET;

END @

Output:

<pre>

=={{header|Tcl}}==

A proc like assert is always good to have around. This one tries to report values used in its expression using subst:

if {![uplevel 1 [list expr $expr]]} {

set msg "{$expr}"

tailcall throw {ASSERT ERROR} $msg

}

isin itself is a simple package. We compute the alphabet when the package is loaded in _init, because that's more fun than typing out the table:

proc _init {} { ;# sets up the map used on every call

variable map

}

To run the test suite, we use the tcltest framework included with Tcl:

tcltest::test isin-1 "Test isin validation" -body {

}

return ok

=={{header|Transact-SQL}}==

CREATE FUNCTION dbo._ISINCheck( @strISIN VarChar(40) )

RETURNS bit

RETURN @bValid

END

Testing

-- Testing. The following tests all pass.

;WITH ISIN_Tests AS

)

SELECT ISIN, Expected, dbo._ISINCheck(ISIN) AS TestResult FROM ISIN_Tests ORDER BY ISIN

=={{header|VBScript}}==

buf=buf&test("US0378331005")&vbCrLf

end if

test=cc&" "&msg

{{out}}

<pre>

{{works with|Visual Basic|VB6 Standard}}

Calls LuhnCheckPassed() function described at [[Luhn_test_of_credit_card_numbers#Visual_Basic]]

Dim s As String, c As String

Dim i As Long

IsValidISIN = LuhnCheckPassed(s)

End If

Test:

Debug.Assert IsValidISIN("US0378331005")

Debug.Assert Not IsValidISIN("US0373831005")

Debug.Assert IsValidISIN("FR0000988040")

Debug.Assert Not IsValidISIN("FR000098804O")

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

{{trans|C#}}

Imports System.Text.RegularExpressions

End Sub

{{out}}

<pre>US0378331005 is valid

=={{header|Vlang}}==

{{trans|go}}

const (

}

}

{{out}}

<pre>expected true for US0378331005, got false

{{libheader|Wren-fmt}}

The Luhn test method is reproduced here for convenience.

import "/trait" for Stepped

import "/fmt" for Conv, Fmt

var ans = (isin.call(test)) ? "valid" : "not valid"

System.print("%(Fmt.s(-13, test)) -> %(ans)")

{{out}}

=={{header|XPL0}}==

func Luhn(Str); \Return 'true' if digits in Str pass Luhn test

CrLf(0);

];

{{out}}

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

local i, j, s1, s2, l

if luhntest(test_str$) then print " Valid" else print " Invalid, checksum error" end if

loop

=={{header|zkl}}==

Uses the luhn test from [[Luhn_test_of_credit_card_numbers#zkl]] (copied here as it is short).

RegExp(String("^","[A-Z]"*2,"[A-Z0-9]"*9,"[0-9]$")).matches(isin) and

luhnTest(isin.split("").apply("toInt",36).concat().toInt())

0 == (n.split().reverse().reduce(fcn(s,n,clk){

s + if(clk.inc()%2) n else 2*n%10 + n/5 },0,Ref(1)) %10)

foreach isin in (T("US0378331005","US0373831005","U50378331005",

"US03378331005","AU0000XVGZA3","AU0000VXGZA3","FR0000988040")){

println(isin," --> ",validateISIN(isin));

{{out}}

<pre>