SEDOLs: Difference between revisions

{{task|Checksums}}

 

For each number list of '''6'''-digit [[wp:SEDOL|SEDOL]]s, calculate and append the checksum digit.

 

B0YBKJ

406566

585284

B0YBKT

B0YBKJ7

4065663

5852842

B0YBKT7

 

 

 

=={{header|ActionScript}}==

//ActionScript does not have a character type, so 1-digit strings

//are used instead

printWithCheck("585284");

printWithCheck("B0YBKT");

 

=={{header|Ada}}==

 

procedure Test_SEDOL is

Put_Line (Test (Index) & Character'Val (Character'Pos ('0') + Check (Test (Index))));

end loop;

The function Check raises Constraint_Error upon an invalid input. The calculated sum is trimmed using (-''sum'') mod 10, which is mathematically equivalent to (10 - (''sum'' mod 10)) mod 10.

 

{{trans|C}}

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - ''char in string'', ''is alpha'', ''is digit'' and ''to upper'' are not in the standard's prelude}}

STRING reject = "AEIOUaeiou";

OD;

done: SKIP

Output:

<pre>7108899

5852842

B0YBKT7</pre>

 

=={{header|AutoHotkey}}==

ahk forum: [http://www.autohotkey.com/forum/post-276683.html#276683 discussion]

MsgBox % SEDOL("B0YBKJ") ;B0YBKJ7

MsgBox % SEDOL("406566") ;4065663

 

SEDOL(w) {

 

=={{header|AWK}}==

Validate or calculate checksum of SEDOL codes read from standard input (one per line)

{

return amap[a]

print sedol sedolcheck

}

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

DO

INPUT a$

NEXT i

getSedolCheckDigit = (10 - (total MOD 10)) MOD 10

 

=={{header|C}}==

'''Notes''': it reads the codes from standard input, one per line (linefeed terminated); the input encoding must meet the following specifications: single byte encoding, digits (0-9) must have codes that follow the same order of the digits (0, 1, 2, ...) and similar for letters, the encoding must match the one used with the compiled source (likely, ASCII based encodings). This should happen 99% of the time (for ASCII, ISO-8859 family and UTF-8 have the same byte encoding for alphanumeric characters).

 

#include <ctype.h>

#include <string.h>

}

return 0;

 

Fed the input list from the task description, the output is:

5852842

B0YBKT7</pre>

 

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

static int sedolChecksum(string sedol)

{

 

return (10 - (sum % 10)) % 10;

 

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

Implemented from scratch using the description on Wikipedia as specification.

{{Works with|ClozureCL}}

(assert (<= 0 start end (length sedol)))

(assert (= (- end start) 6))

(head (subseq sedol start end))

(tail (digit-char posn)))

 

=={{header|D}}==

===Functional Version===

 

in {

assert(sedol.length == 6);

} out (result) {

} body {

}

 

void main() {

{{out}}

<pre>7108899

5852842

B0YBKT7</pre>

===Imperative Version===

Longer, faster lower-level version, same output.

 

in {

assert(sedol.length == 6, "SEDOL must be 6 chars long.");

enum uint mask = 0b11_1110_1111_1011_1110_1110_1110;

 

(c > 'A' && c <= 'Z' && ((1U << (c - 'A')) & mask)),

"SEDOL with wrong char.");

} out(result) {

assert((d + result - '0') % 10 == 0);

} body {

 

int sum = 0;

sum += (c - '0') * weights[i];

else

 

void main() {

===Short Version===

Same output.

 

 

 

=={{header|E}}==

def Digit := ('0'..'9')

def Letter := ('B'..'D'|'F'..'H'|'J'..'N'|'P'..'T'|'V'..'Z')

B0YBKT".trim().split("\n") {

println(addChecksum(sedol.trim()))

 

=={{header|Forth}}==

 

: char>num ( '0-9A-Z' -- 0..35 )

sedol" B0YBKR" B0YBKR5 ok

sedol" 585284" 5852842 ok

 

=={{header|Fortran}}==

{{Works with|Fortran|90 and later}}

IMPLICIT NONE

CONTAINS

END DO

Output

710889 7108899

585284 5852842

B0YBKT B0YBKT7

=={{header|Go}}==

package main

 

}

}

Output:

<pre>

 

=={{header|Groovy}}==

assert text.size() == 6 && !text.toUpperCase().find(/[AEIOU]+/) : "Invalid SEDOL text: $text"

 

text + (10 - (sum % 10)) % 10

}

Test Code:

'228276': '2282765', 'B0YBKL': 'B0YBKL9', '557910': '5579107', 'B0YBKR': 'B0YBKR5',

'585284': '5852842', 'B0YBKT': 'B0YBKT7', 'B00030': 'B000300'].each { text, expected ->

println "Checking $text -> $expected"

assert expected == text.sedol()

Output:

<pre>Checking 710889 -> 7108899

 

=={{header|Haskell}}==

 

 

 

 

 

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

every write(sedol("710889"|"B0YBKJ"|"406566"|"B0YBLH"|"228276"|

"B0YBKL"|"557910"|"B0YBKR"|"585284"|"B0YBKT"|"B00030"))

return x || (10 - (t%10)) % 10 # complete

}

 

=={{header|J}}==

There are several ways to perform this in J. This most closely follows the algorithmic description at Wikipedia:

 

The fundamental operation is the linear combination (<tt>+/@:*</tt>) and neither argument is "special". In particular, the coefficients are just another array participating in the calculation, and there's no reason we can't modify them as easily as the input array. Having this insight, it is obvious that manipulating the coefficients, rather than the input array, will be more efficient (because the coefficients are fixed at small size, while the input array can be arbitrarily large).

 

Which leads us to this more efficient formulation:

which reduces to:

Which is just as concise as <tt>ac0</tt>, but faster.

 

 

Which leads us to:

 

=={{header|Java}}==

 

public class SEDOL{

return (str.length() == 6) && !str.toUpperCase().matches(".*?[AEIOU].*?");

}

 

=={{header|JavaScript}}==

return input + sedol_check_digit(input);

}

print("error: " + e);

}

output

<pre>7108899

1234563

error: Invalid SEDOL number '1234567'</pre>

 

=={{header|Liberty BASIC}}==

'adapted from BASIC solution

mult(1) = 1: mult(2) = 3: mult(3) = 1

getSedolCheckDigit = (10 - (total MOD 10)) MOD 10

END FUNCTION

 

=={{header|M4}}==

changequote(`[',`]')

define([_bar],include(sedol.inp))

])

divert

 

Code<>ToString[10-Mod[ToExpression[Quiet[Flatten[Characters[Code]

/.x_?LetterQ->(ToCharacterCode[x]-55)]]].{1,3,1,7,3,9},10]]

7108899

B0YBKJ7

B0YBKT7

B0003010

 

=={{header|Mercury}}==

:- interface.

 

is_vowel('I').

is_vowel('O').

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt, Text, Stdio;

| BadSedol(text) => IO.Put(text & "\n", Stdio.stderr);

END;

Output:

<pre>7108899

 

=={{header|MUMPS}}==

NEW A,B

SEDOL1

NEW UP,LO

SET UP="ABCDEFGHIJKLMNOPQRSTUVWXYZ",LO="abcdefghijklmnopqrstuvwxyz"

Examples:

<pre>USER>D SEDOL^ROSETTA

Enter the first 6 digits of a SEDOL: B123456

INVALID</pre>

 

=={{header|OCaml}}==

assert (not (String.contains "AEIOU" c));

match c with

let sedolweight = [1;3;1;7;3;9]

let explode s =

let checksum sedol =

let tmp = List.fold_left2 (fun sum ch weight -> sum + char2value ch * weight)

0 (explode sedol) sedolweight in

List.iter (fun sedol -> print_endline (sedol ^ checksum sedol))

[ "710889";

"B0YBKR";

"585284";

 

=={{header|Pascal}}==

{{works with|Free_Pascal}}

 

function index(c: char): integer;

writeln(codes[i], ' -> ', seforl);

end;

Output:

<pre>% ./Sedols

=={{header|Perl}}==

This program reads from standard input.

use POSIX qw(strtol);

 

my $f = shift;

my @a = @{shift()};

 

my @weights = (1, 3, 1, 7, 3, 9);

my $s = shift;

$s =~ /[AEIOU]/ and die "No vowels";

chomp;

print sedol($_), "\n";

 

 

 

 

 

=={{header|PHP}}==

assert(stripos('AEIOU', $c) === FALSE);

return intval($c, 36);

'585284',

'B0YBKT') as $sedol)

 

=={{header|PicoLisp}}==

(pack Str

(char

 

(for S '("710889" "B0YBKJ" "406566" "B0YBLH" "228276" "B0YBKL" "557910" "B0YBKR" "585284" "B0YBKT" "B00030")

 

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

sedol: procedure options (main); /* 3 March 2012 */

declare alphabet character (36) static initial

put edit (s, v) (x(2), a, f(1)); put edit (' ') (a);

end;

<pre>

710889 7108899

B00030 B000300

</pre>

 

=={{header|PureBasic}}==

Protected i, j, sum, c, m

For i=1 To Len(rawstring$)

Data.s "710889","B0YBKJ","406566","B0YBLH","228276"

Data.s "B0YBKL","557910","B0YBKR","585284","B0YBKT","B00030"

 

[[Image:PB SEDOL.png]]

 

=={{header|Python}}==

assert c not in 'AEIOU', "No vowels"

return int(c, 36)

sedol, sedolweight)

)

 

for sedol in '''

B0YBKT

'''.split():

 

=={{header|R}}==

datalines <- readLines(tc <- textConnection("710889

B0YBKJ

 

#Print in format requested

 

 

 

 

 

 

 

 

 

 

 

710889

B0YBKJ

585284

B0YBKT

puts sedol + checksum(sedol)

 

=={{header|Scala}}==

require(s.size == 6 || s.size == 7, "SEDOL length must be 6 or 7 characters")

require(s.size == 6 || s(6).asDigit == chksum, "Incorrect SEDOL checksum")

def chksum = 10 - ((s zip List(1, 3, 1, 7, 3, 9) map { case (c, w) => c.asDigit * w } sum) % 10)

override def toString = s.take(6) + chksum

 

Test cases:

 

=={{header|Seed7}}==

 

const func char: sedolCheckDigit (in string: sedol) is func

writeln(sedol <& sedolCheckDigit(sedol));

end for;

 

<pre>

7108899

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

includesAnyOf: aSet [

aSet do: [ :e | (self includes: e) ifTrue: [ ^true ] ].

^false

]

 

|weight charList|

 

]

]

 

sedol := SEDOL new.

{ '710889'.

'B0YBKR'.

'585284'.

 

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

if List.exists (fn x => x = c) (explode "AEIOU") then raise Fail "no vowels"

else if Char.isDigit c then ord c - ord #"0"

"B0YBKR",

"585284",

 

=={{header|Tcl}}==

variable chars {0 1 2 3 4 5 6 7 8 9 "" B C D "" F G H "" J K L M N "" P Q R S T "" V W X Y Z}

variable weight {1 3 1 7 3 9 1}

assert {$sedol eq $answer} "assertion failed: $sedol ne $answer"

puts $sedol

 

 

( @SEDOL varchar(50) )

RETURNS varchar(7)

-- Return the result of the function

RETURN @SEDOL

 

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

check="1'3'1'7'3'9"

PRINT input, " checkdigit: ", checksum

ENDLOOP

Output:

<pre>

to the list of character values.

 

#import nat

 

charval = -:@rlXS num alphabet

iprod = sum:-0+ product*p/weights+ charval*

 

An optimization following the J solution avoids a run-time subtraction

by complementing the coefficients at compile time using these

definitions in place of those above.

 

A further performance improvement subsumes the character value lookup

the version shown below.

 

 

To optimize further, we can build a separate smaller multiplication table for

index directly into the input list.

 

Here is a test program.

 

examples = ^T(~&,~&h+ %nP+ checksum)*t

B0YBKR

585284

output:

<pre>7108899

5852842

B0YBKT7</pre>

 

{{omit from|GUISS}}