Rosetta Code

SEDOLs: Difference between revisions

Page Discussion

SEDOLs (view source)

Revision as of 13:16, 28 August 2022

3,025 bytes added ,  1 year ago
m
syntax highlighting fixup automation
m (syntax highlighting fixup automation)
Line 46:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F char2value(c)
assert(c !C ‘AEIOU’, ‘No vowels’)
R Int(c, radix' 36)
Line 69:
 
L(sedol) sedols.split("\n")
print(sedol‘’checksum(sedol))</langsyntaxhighlight>
 
{{out}}
Line 86:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">INT FUNC SedolChecksum(CHAR ARRAY sedol)
BYTE ARRAY weights=[1 3 1 7 3 9]
INT i,sum
Line 144:
Test("12345")
Test("1234567")
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/SEDOLs.png Screenshot from Atari 8-bit computer]
Line 165:
 
=={{header|ActionScript}}==
<langsyntaxhighlight ActionScriptlang="actionscript">//Return the code corresponding to a given character.
//ActionScript does not have a character type, so 1-digit strings
//are used instead
Line 214:
printWithCheck("585284");
printWithCheck("B0YBKT");
printWithCheck("B00030");</langsyntaxhighlight>
 
=={{header|Ada}}==
<langsyntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
 
procedure Test_SEDOL is
Line 256:
Put_Line (Test (Index) & Character'Val (Character'Pos ('0') + Check (Test (Index))));
end loop;
end Test_SEDOL;</langsyntaxhighlight>
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.
 
Line 274:
{{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}}
<langsyntaxhighlight lang="algol68">[]INT sedol weights = (1, 3, 1, 7, 3, 9);
STRING reject = "AEIOUaeiou";
Line 331:
OD;
done: SKIP
)</langsyntaxhighlight>
Output:
<pre>7108899
Line 345:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin
% returns the check digit for the specified SEDOL %
string(1) procedure sedolCheckDigit ( string(6) value sedol ) ;
Line 387:
testCheckDigit( "B0YBKT", "7" );
testCheckDigit( "B00030", "0" )
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 405:
=={{header|AppleScript}}==
 
<langsyntaxhighlight lang="applescript">on appendCheckDigitToSEDOL(sedol)
if ((count sedol) is not 6) then ¬
return {false, "Error in appendCheckDigitToSEDOL handler: " & sedol & " doesn't have 6 characters."}
Line 447:
set output to output as text
set AppleScript's text item delimiters to astid
return output</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">"7108899
B0YBKJ7
4065663
Line 460:
5852842
B0YBKT7
B000300"</langsyntaxhighlight>
 
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">ord0: to :integer `0`
ord7: to :integer `7`
c2v: function [c][
Line 488:
 
loop sedols 'sed ->
print [sed "->" sed ++ checksum sed]</langsyntaxhighlight>
 
{{out}}
Line 508:
 
===Full===
<langsyntaxhighlight AutoHotkeylang="autohotkey">codes = 710889,B0YBKJ,406566,B0YBLH,228276,B0YBKL,557910,B0YBKR,585284,B0YBKT,B00030,ABCDEF,BBBBBBB
Loop, Parse, codes, `,
output .= A_LoopField "`t-> " SEDOL(A_LoopField) "`n"
Line 526:
Return "Invalid character."
Return code . Mod(10-Mod(check_digit,10),10)
}</langsyntaxhighlight>
 
===Short===
{{works with|AutoHotkey 1.1}}
<langsyntaxhighlight AutoHotkeylang="autohotkey">MsgBox % SEDOL("710889") ;7108899
MsgBox % SEDOL("B0YBKJ") ;B0YBKJ7
MsgBox % SEDOL("406566") ;4065663
Line 546:
s += ((c := Asc(A_LoopField)) >= 65 ? c - 65 + 10 : c - 48) * weights[A_Index]
return w Mod(10 - Mod(s, 10), 10)
}</langsyntaxhighlight>
 
=={{header|AWK}}==
Validate or calculate checksum of SEDOL codes read from standard input (one per line)
<langsyntaxhighlight lang="awk">function ord(a)
{
return amap[a]
Line 598:
print sedol sedolcheck
}
}</langsyntaxhighlight>
 
=={{header|BASIC}}==
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<langsyntaxhighlight lang="qbasic">DECLARE FUNCTION getSedolCheckDigit! (str AS STRING)
DO
INPUT a$
Line 633:
NEXT i
getSedolCheckDigit = (10 - (total MOD 10)) MOD 10
END FUNCTION</langsyntaxhighlight>
 
=={{header|BBC BASIC}}==
<langsyntaxhighlight lang="bbcbasic"> PRINT FNsedol("710889")
PRINT FNsedol("B0YBKJ")
PRINT FNsedol("406566")
Line 656:
s% += (a% + 7 * (a% > 9)) * weights%(i%)
NEXT
= d$ + CHR$(&30 + (10 - s% MOD 10) MOD 10)</langsyntaxhighlight>
'''Output:'''
<pre>
Line 675:
'''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).
 
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <ctype.h>
#include <string.h>
Line 722:
}
return 0;
}</langsyntaxhighlight>
 
Fed the input list from the task description, the output is:
Line 738:
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">static int[] sedol_weights = { 1, 3, 1, 7, 3, 9 };
static int sedolChecksum(string sedol)
{
Line 764:
 
return (10 - (sum % 10)) % 10;
}</langsyntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">
#include <numeric>
#include <cctype>
Line 811:
return 0;
}
</syntaxhighlight>
</lang>
 
=={{header|Caché ObjectScript}}==
 
<langsyntaxhighlight lang="cos">Class Utils.Check [ Abstract ]
{
 
Line 833:
}
 
}</langsyntaxhighlight>
{{out|Examples}}
<pre>USER>For { Read s Quit:s="" Write ": "_##class(Utils.Check).SEDOL(s), ! }
Line 851:
 
=={{header|Clojure}}==
<langsyntaxhighlight Clojurelang="clojure">(defn sedols [xs]
(letfn [(sedol [ys] (let [weights [1 3 1 7 3 9]
convtonum (map #(Character/getNumericValue %) ys)
check (-> (reduce + (map * weights convtonum)) (rem 10) (->> (- 10)) (rem 10))]
(str ys check)))]
(map #(sedol %) xs)))</langsyntaxhighlight>
 
=={{header|COBOL}}==
{{works with|GNU Cobol|2.0}}
<langsyntaxhighlight lang="cobol"> >>SOURCE FREE
IDENTIFICATION DIVISION.
PROGRAM-ID. sedol.
Line 938:
CLOSE sedol-file
.
END PROGRAM sedol.</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Implemented from scratch using the description on Wikipedia as specification.
{{Works with|ClozureCL}}
<langsyntaxhighlight lang="lisp">(defun append-sedol-check-digit (sedol &key (start 0) (end (+ start 6)))
(assert (<= 0 start end (length sedol)))
(assert (= (- end start) 6))
Line 954:
(head (subseq sedol start end))
(tail (digit-char posn)))
(return (concatenate 'string head (list tail))))))</langsyntaxhighlight>
 
=={{header|D}}==
===Functional Version===
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.string, std.numeric, std.ascii;
 
char checksum(in char[] sedol) pure @safe /*@nogc*/
Line 977:
B0YBKL 557910 B0YBKR 585284 B0YBKT".split)
writeln(sedol, sedol.checksum);
}</langsyntaxhighlight>
{{out}}
<pre>7108899
Line 992:
===Imperative Version===
Longer, faster lower-level version, same output.
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.string, std.numeric, std.ascii;
 
char sedolChecksum(in char[] sedol) pure nothrow @safe /*@nogc*/
Line 1,029:
"585284", "B0YBKT"])
writeln(s, s.sedolChecksum);
}</langsyntaxhighlight>
 
===Short Version===
Same output.
<langsyntaxhighlight lang="d">void main() {
import std.stdio, std.algorithm, std.string, std.numeric,std.ascii;
 
Line 1,041:
.map!(c => c.isDigit ? c - '0' : c - 'A' + 10)
.dotProduct([1, 3, 1, 7, 3, 9]) % 10);
}</langsyntaxhighlight>
 
=={{header|Delphi}}==
 
<langsyntaxhighlight Delphilang="delphi">program Sedol;
 
{$APPTYPE CONSOLE}
Line 1,124:
readln;
end.
</syntaxhighlight>
</lang>
 
Output:
Line 1,140:
 
=={{header|E}}==
<langsyntaxhighlight lang="e">def weights := [1,3,1,7,3,9]
def Digit := ('0'..'9')
def Letter := ('B'..'D'|'F'..'H'|'J'..'N'|'P'..'T'|'V'..'Z')
Line 1,176:
B0YBKT".trim().split("\n") {
println(addChecksum(sedol.trim()))
}</langsyntaxhighlight>
 
=={{header|Elixir}}==
{{trans|Ruby}}
<langsyntaxhighlight lang="elixir">defmodule SEDOL do
@sedol_char "0123456789BCDFGHJKLMNPQRSTVWXYZ" |> String.codepoints
@sedolweight [1,3,1,7,3,9]
Line 1,222:
e in ArgumentError -> IO.inspect e
end
end)</langsyntaxhighlight>
 
{{out}}
Line 1,251:
{{Works with|Office 365 Betas 2021}}
 
<langsyntaxhighlight lang="lisp">SEDOLCHECKSUM
=LAMBDA(s,
IF(6 = LEN(s),
Line 1,283:
"Expected a 6-character SEDOL"
)
)</langsyntaxhighlight>
 
and also assuming that the names ELEM and MUL are bound to the following reusable lambdas in Name Manager:
 
<langsyntaxhighlight lang="lisp">ELEM
=LAMBDA(x,
LAMBDA(xs,
Line 1,296:
 
MUL
=LAMBDA(a, LAMBDA(b, a * b))</langsyntaxhighlight>
{{Out}}
 
Line 1,392:
 
=={{header|F Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">open System
let Inputs = ["710889"; "B0YBKJ"; "406566"; "B0YBLH"; "228276"; "B0YBKL"
"557910"; "B0YBKR"; "585284"; "B0YBKT"; "B00030"]
Line 1,419:
addCheckDigit Inputs |> List.iter (printfn "%s")
with
ex -> printfn "ERROR: %s" ex.Message</langsyntaxhighlight>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: combinators combinators.short-circuit formatting io kernel
math math.parser regexp sequences unicode ;
IN: rosetta-code.sedols
Line 1,463:
input [ dup sedol-check-digit "%-6s %s\n" printf ] each ;
 
MAIN: sedol-demo</langsyntaxhighlight>
{{out}}
<pre>
Line 1,486:
 
=={{header|Forth}}==
<langsyntaxhighlight lang="forth">create weight 1 , 3 , 1 , 7 , 3 , 9 ,
 
: char>num ( '0-9A-Z' -- 0..35 )
Line 1,513:
sedol" B0YBKR" B0YBKR5 ok
sedol" 585284" 5852842 ok
sedol" B0YBKT" B0YBKT7 ok</langsyntaxhighlight>
 
=={{header|Fortran}}==
{{Works with|Fortran|90 and later}}
<langsyntaxhighlight lang="fortran">MODULE SEDOL_CHECK
IMPLICIT NONE
CONTAINS
Line 1,559:
END DO
END PROGRAM SEDOLTEST</langsyntaxhighlight>
Output
710889 7108899
Line 1,573:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight FreeBASIClang="freebasic">' version 05-07-2015
' compile with: fbc -s console
 
Line 1,665:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre>Calculated checksum
Line 1,703:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=905f91c785f1f15a360726717731862f Click this link to run this code]'''
<langsyntaxhighlight lang="gambas">Public Sub Main()
Dim byWeight As Byte[] = [1, 3, 1, 7, 3, 9, 1]
Dim byCount, byCompute As Byte
Line 1,731:
Next
 
End</langsyntaxhighlight>
Output:
<pre>
Line 1,748:
 
=={{header|Go}}==
<syntaxhighlight lang="go">
<lang go>
package main
 
Line 1,811:
}
}
</syntaxhighlight>
</lang>
Output:
<pre>
Line 1,839:
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">def checksum(text) {
assert text.size() == 6 && !text.toUpperCase().find(/[AEIOU]+/) : "Invalid SEDOL text: $text"
 
Line 1,848:
text + (10 - (sum % 10)) % 10
}
String.metaClass.sedol = { this.&checksum(delegate) }</langsyntaxhighlight>
Test Code:
<langsyntaxhighlight lang="groovy">[ '710889': '7108899', 'B0YBKJ': 'B0YBKJ7', '406566': '4065663', 'B0YBLH': 'B0YBLH2',
'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()
}</langsyntaxhighlight>
Output:
<pre>Checking 710889 -> 7108899
Line 1,870:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.Char (isAsciiUpper, isDigit, ord)
 
-------------------------- SEDOLS ------------------------
Line 1,918:
"BOYBKT", -- Ill formed test case - illegal vowel.
"B00030"
]</langsyntaxhighlight>
{{Out}}
<pre>7108899
Line 1,934:
 
=={{header|Icon}} and {{header|Unicon}}==
<langsyntaxhighlight Iconlang="icon">procedure main()
every write(sedol("710889"|"B0YBKJ"|"406566"|"B0YBLH"|"228276"|
"B0YBKL"|"557910"|"B0YBKR"|"585284"|"B0YBKT"|"B00030"))
Line 1,952:
return x || (10 - (t%10)) % 10 # complete
}
end</langsyntaxhighlight>
 
=={{header|J}}==
There are several ways to perform this in J. This most closely follows the algorithmic description at Wikipedia:
<langsyntaxhighlight lang="j">sn =. '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ac0 =: (, 10 | 1 3 1 7 3 9 +/@:* -)&.(sn i. |:)</langsyntaxhighlight>
However, because J is so concise, having written the above, it becomes clear that the negation (<tt>-</tt>) is unnecessary.
 
Line 1,963:
 
Which leads us to this more efficient formulation:
<langsyntaxhighlight lang="j">ac1 =: (, 10 | (10 - 1 3 1 7 3 9) +/@:* ])&.(sn i. |:)</langsyntaxhighlight>
which reduces to:
<langsyntaxhighlight lang="j">ac2 =: (, 10 | 9 7 9 3 7 1 +/@:* ])&.(sn i. |:)</langsyntaxhighlight>
Which is just as concise as <tt>ac0</tt>, but faster.
 
Line 1,971:
 
Which leads us to:
<langsyntaxhighlight lang="j">ac3 =: (,"1 0 (841 $ '0987654321') {~ 1 3 1 7 3 9 +/ .*~ sn i. ])</langsyntaxhighlight>
Which is more than twice as fast as even the optimized formulation (<tt>ac2</tt>), though it is slightly longer.
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.util.Scanner;
 
public class SEDOL{
Line 2,005:
return (str.length() == 6) && !str.toUpperCase().matches(".*?[AEIOU].*?");
}
}</langsyntaxhighlight>
 
=={{header|JavaScript}}==
===Imperative===
<langsyntaxhighlight lang="javascript">function sedol(input) {
return input + sedol_check_digit(input);
}
Line 2,049:
print("error: " + e);
}
}</langsyntaxhighlight>
output
<pre>7108899
Line 2,067:
 
===Functional===
<langsyntaxhighlight lang="javascript">(() => {
'use strict';
 
Line 2,230:
// MAIN ---
return main();
})();</langsyntaxhighlight>
{{Out}}
<pre>7108899
Line 2,247:
{{works with|jq|1.4}}
This implementation accepts strings with lowercase letters, but converts them to uppercase.
<langsyntaxhighlight lang="jq">def ascii_upcase:
explode | map( if 97 <= . and . <= 122 then . - 32 else . end) | implode;
 
Line 2,289:
else $ans
end ;
sedolize</langsyntaxhighlight>
{{Out}}
# Assuming sedol.txt contains the input in the task description
Line 2,298:
{{works with|Julia|0.6}}
 
<langsyntaxhighlight lang="julia">using Base.Test
 
function appendchecksum(chars::AbstractString)
Line 2,318:
@test appendchecksum(t) == c
end
end</langsyntaxhighlight>
 
{{out}}
Line 2,325:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.0
 
val weights = listOf(1, 3, 1, 7, 3, 9, 1)
Line 2,349:
"557910", "B0YBKR", "585284", "B0YBKT", "B00030")
for (sedol6 in sedol6s) println("$sedol6 -> ${sedol7(sedol6)}")
}</langsyntaxhighlight>
 
{{out}}
Line 2,369:
{{trans|Go}}
{{works with|langur|0.8.10}}
<langsyntaxhighlight lang="langur">val .csd = f(.code) {
given len(.code) {
case 0:
Line 2,426:
$" (SEDOL test failed; expected check digit \.expect;)"}
}
}</langsyntaxhighlight>
 
{{out}}
Line 2,451:
 
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
<lang lb>
'adapted from BASIC solution
mult(1) = 1: mult(2) = 3: mult(3) = 1
Line 2,483:
getSedolCheckDigit = (10 - (total MOD 10)) MOD 10
END FUNCTION
</syntaxhighlight>
</lang>
 
=={{header|M4}}==
<langsyntaxhighlight M4lang="m4">divert(-1)
changequote(`[',`]')
define([_bar],include(sedol.inp))
Line 2,502:
])
divert
eachline(_bar,[checksum])</langsyntaxhighlight>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">SEDOL[Code_?(Function[v,StringFreeQ[v,{"A","E","I","O","U"}]])]:=
Code<>ToString[10-Mod[ToExpression[Quiet[Flatten[Characters[Code]
/.x_?LetterQ->(ToCharacterCode[x]-55)]]].{1,3,1,7,3,9},10]]
Scan[Print[SEDOL[#]] &, {"710889","B0YBKJ","406566","B0YBLH","228276","B0YBKL","557910","B0YBKR","585284","B0YBKT","B00030","DUMMY"}]</langsyntaxhighlight>
{{out}}
<pre>
Line 2,525:
 
=={{header|Mercury}}==
<syntaxhighlight lang="text">:- module sedol.
:- interface.
 
Line 2,577:
is_vowel('I').
is_vowel('O').
is_vowel('U').</langsyntaxhighlight>
 
=={{header|Modula-3}}==
<langsyntaxhighlight lang="modula3">MODULE SEDOL EXPORTS Main;
 
IMPORT IO, Fmt, Text, Stdio;
Line 2,623:
| BadSedol(text) => IO.Put(text & "\n", Stdio.stderr);
END;
END SEDOL.</langsyntaxhighlight>
Output:
<pre>7108899
Line 2,637:
 
=={{header|MUMPS}}==
<langsyntaxhighlight MUMPSlang="mumps">SEDOL
NEW A,B
SEDOL1
Line 2,657:
NEW UP,LO
SET UP="ABCDEFGHIJKLMNOPQRSTUVWXYZ",LO="abcdefghijklmnopqrstuvwxyz"
QUIT $TRANSLATE(X,LO,UP)</langsyntaxhighlight>
Examples:
<pre>USER>D SEDOL^ROSETTA
Line 2,689:
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">proc c2v(c: char): int =
assert c notin "AEIOU"
if c < 'A': ord(c) - ord('0') else: ord(c) - ord('7')
Line 2,704:
"228276", "B0YBKL", "557910", "B0YBKR",
"585284", "B0YBKT", "B00030"]:
echo sedol, " → ", sedol & checksum(sedol)</langsyntaxhighlight>
 
{{out}}
Line 2,720:
 
=={{header|OCaml}}==
<langsyntaxhighlight lang="ocaml">let char2value c =
assert (not (String.contains "AEIOU" c));
match c with
Line 2,747:
"B0YBKR";
"585284";
"B0YBKT" ]</langsyntaxhighlight>
 
=={{header|Oforth}}==
 
<langsyntaxhighlight Oforthlang="oforth">func: sedol(s)
[ 1, 3, 1, 7, 3, 9 ] s
zipWith(#[ dup isDigit ifTrue: [ '0' - ] else: [ 'A' - 10 + ] * ]) sum
10 mod 10 swap - 10 mod
StringBuffer new s << swap '0' + <<c ;</langsyntaxhighlight>
 
{{out}}
Line 2,776:
=={{header|Pascal}}==
{{works with|Free_Pascal}}
<langsyntaxhighlight lang="pascal">program Sedols(output);
 
function index(c: char): integer;
Line 2,820:
writeln(codes[i], ' -> ', seforl);
end;
end.</langsyntaxhighlight>
Output:
<pre>% ./Sedols
Line 2,837:
=={{header|Perl}}==
This program reads from standard input.
<langsyntaxhighlight lang="perl">use List::Util qw(sum);
use POSIX qw(strtol);
 
Line 2,862:
chomp;
print sedol($_), "\n";
}</langsyntaxhighlight>
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">type</span> <span style="color: #000000;">string6</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #004080;">string</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">6</span>
Line 2,898:
<span style="color: #0000FF;">?</span><span style="color: #000000;">sedol</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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 2,915:
 
=={{header|PHP}}==
<langsyntaxhighlight lang="php">function char2value($c) {
assert(stripos('AEIOU', $c) === FALSE);
return intval($c, 36);
Line 2,940:
'585284',
'B0YBKT') as $sedol)
echo $sedol, checksum($sedol), "\n";</langsyntaxhighlight>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de sedol (Str)
(pack Str
(char
Line 2,963:
 
(for S '("710889" "B0YBKJ" "406566" "B0YBLH" "228276" "B0YBKL" "557910" "B0YBKR" "585284" "B0YBKT" "B00030")
(prinl (sedol S)) )</langsyntaxhighlight>
 
=={{header|PL/I}}==
<langsyntaxhighlight PLIlang="pli">/* Compute SEDOLs; includes check for invalid characters. */
sedol: procedure options (main); /* 3 March 2012 */
declare alphabet character (36) static initial
Line 2,988:
put edit (s, v) (x(2), a, f(1)); put edit (' ') (a);
end;
end sedol;</langsyntaxhighlight>
 
{{out}}
Line 3,007:
=={{header|Potion}}==
No extra credit.
<langsyntaxhighlight lang="potion">sedolnum = (c) :
if ("0" ord <= c ord and c ord <= "9" ord): c number integer.
else: 10 + c ord - "A" ord.
Line 3,019:
.
(str, (10 - (sum % 10)) % 10) join
.</langsyntaxhighlight>
 
=={{header|PowerShell}}==
<langsyntaxhighlight lang="powershell">function Add-SEDOLCheckDigit
{
Param ( # Validate input as six-digit SEDOL number
Line 3,069:
{
Add-SEDOLCheckDigit -SixDigitSEDOL $PartialSEDOL
}</langsyntaxhighlight>
{{out}}
<pre>7108899
Line 3,084:
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">Procedure.s SEDOLs(rawstring$)
Protected i, j, sum, c, m
For i=1 To Len(rawstring$)
Line 3,123:
Data.s "710889","B0YBKJ","406566","B0YBLH","228276"
Data.s "B0YBKL","557910","B0YBKR","585284","B0YBKT","B00030"
EndDataSection</langsyntaxhighlight>
 
[[Image:PB SEDOL.png]]
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">def char2value(c):
assert c not in 'AEIOU', "No vowels"
return int(c, 36)
Line 3,152:
B0YBKT
'''.split():
print sedol + checksum(sedol)</langsyntaxhighlight>
 
 
Line 3,158:
 
{{Works with|Python|3.7}}
<langsyntaxhighlight lang="python">'''SEDOL checksum digits'''
 
from functools import reduce
Line 3,282:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>SEDOL checksum digits:
Line 3,300:
 
=={{header|Q}}==
<langsyntaxhighlight lang="q">scd:{
v:{("i"$x) - ?[("0"<=x) & x<="9"; "i"$"0"; -10+"i"$"A"]} each x; / Turn characters of SEDOL into their values
w:sum v*1 3 1 7 3 9; / Weighted sum of values
Line 3,307:
}
 
scd each ("710889";"B0YBKJ";"406566";"B0YBLH";"228276";"B0YBKL";"557910";"B0YBKR";"585284";"B0YBKT";"B00030")</langsyntaxhighlight>
 
=={{header|R}}==
<langsyntaxhighlight lang="rsplus"># Read in data from text connection
datalines <- readLines(tc <- textConnection("710889
B0YBKJ
Line 3,346:
 
#Print in format requested
writeLines(withchkdig)</langsyntaxhighlight>
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">#lang racket
;;; Since the Task gives us unchecksummed and checksummed SEDOLs, and
;;; we'll just take a list of the output SEDOLs and remove their last
Line 3,411:
(check-false (invalid-SEDOL? S))
(check-equal? (SEDOL-append-checksum (substring S 0 6))
S (format "test SEDOL for ~a" S))))</langsyntaxhighlight>
 
Output:
Line 3,434:
{{trans|Perl}}
{{Works with|rakudo|2015-12-17}}
<syntaxhighlight lang="raku" perl6line>sub sedol( Str $s ) {
die 'No vowels allowed' if $s ~~ /<[AEIOU]>/;
die 'Invalid format' if $s !~~ /^ <[0..9B..DF..HJ..NP..TV..Z]>**6 $ /;
Line 3,459:
B0YBKT
B00030
>;</langsyntaxhighlight>
 
=={{header|REXX}}==
Line 3,470:
╚════════════════════════════════════════════════════════════════════╝
</pre>
<langsyntaxhighlight lang="rexx">/*REXX program computes the check digit (last digit) for six or seven character SEDOLs.*/
@abcU = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' /*the uppercase Latin alphabet. */
alphaDigs= '0123456789'@abcU /*legal characters, and then some. */
Line 3,511:
sed: say; say 'SEDOL:' sedol; say; return
ser: say; say '***error***' arg(1); call sed; exit 13
swa: say; say '***warning***' arg(1); say; return</langsyntaxhighlight>
'''output''' &nbsp; when using the defaults:
<pre>
Line 3,528:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
see sedol("710889") + nl
see sedol("B0YBKJ") + nl
Line 3,553:
next
return d + (10 - (s % 10)) % 10
</syntaxhighlight>
</lang>
Output:
<pre>
Line 3,570:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">Sedol_char = "0123456789BCDFGHJKLMNPQRSTVWXYZ"
Sedolweight = [1,3,1,7,3,9]
 
Line 3,606:
p e
end
end</langsyntaxhighlight>
{{out}}
<pre>
Line 3,626:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">
fn sedol(input: &str) -> Option<String> {
let weights = vec![1, 3, 1, 7, 3, 9, 1];
Line 3,673:
}
 
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,690:
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">class SEDOL(s: String) {
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")
Line 3,696:
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
}</langsyntaxhighlight>
 
Test cases:
Line 3,737:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const func char: sedolCheckDigit (in string: sedol) is func
Line 3,771:
writeln(sedol <& sedolCheckDigit(sedol));
end for;
end func;</langsyntaxhighlight>
 
{{out}}
Line 3,790:
=={{header|Sidef}}==
{{trans|Raku}}
<langsyntaxhighlight lang="ruby">func sedol(s) {
 
die 'No vowels allowed' if (s ~~ /[AEIOU]/);
Line 3,818:
).each { |s|
say sedol(s);
}</langsyntaxhighlight>
{{out}}
<pre>
Line 3,836:
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<langsyntaxhighlight lang="smalltalk">String extend [
includesAnyOf: aSet [
aSet do: [ :e | (self includes: e) ifTrue: [ ^true ] ].
^false
]
].</langsyntaxhighlight>
 
<langsyntaxhighlight lang="smalltalk">Object subclass: SEDOL [
|weight charList|
 
Line 3,885:
]
]
].</langsyntaxhighlight>
 
<langsyntaxhighlight lang="smalltalk">|sedol|
sedol := SEDOL new.
{ '710889'.
Line 3,898:
'B0YBKR'.
'585284'.
'B0YBKT' } do: [ :c | (sedol checked: c) displayNl ]</langsyntaxhighlight>
 
{{works with|Smalltalk/X}}
<langsyntaxhighlight lang="smalltalk">#(
'710889'
'B0YBKJ'
Line 3,922:
check := (10 - (sum%10)) % 10.
Transcript showCR: ( in,(Character digitValue:check))
].</langsyntaxhighlight>
{{out}}
7108899
Line 3,939:
{{works with|Db2 LUW}} version 9.7 or higher.
With SQL PL:
<langsyntaxhighlight lang="sql pl">
--#SET TERMINATOR @
 
Line 4,004:
RETURN TEXT || CHECK;
END @
</syntaxhighlight>
</lang>
Output:
<pre>
Line 4,052:
 
=={{header|Standard ML}}==
<langsyntaxhighlight lang="sml">fun char2value c =
if List.exists (fn x => x = c) (explode "AEIOU") then raise Fail "no vowels"
else if Char.isDigit c then ord c - ord #"0"
Line 4,077:
"B0YBKR",
"585284",
"B0YBKT" ];</langsyntaxhighlight>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">namespace eval sedol {
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}
Line 4,117:
assert {$sedol eq $answer} "assertion failed: $sedol ne $answer"
puts $sedol
}</langsyntaxhighlight>
 
=={{header|Transact-SQL}}==
Line 4,123:
Returns empty string if invalid.
 
<langsyntaxhighlight lang="tsql">CREATE FUNCTION [dbo].[fn_CheckSEDOL]
( @SEDOL varchar(50) )
RETURNS varchar(7)
Line 4,185:
-- Return the result of the function
RETURN @SEDOL
END</langsyntaxhighlight>
 
Examples:
Line 4,213:
 
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
check="1'3'1'7'3'9"
Line 4,234:
PRINT input, " checkdigit: ", checksum
ENDLOOP
</syntaxhighlight>
</lang>
Output:
<pre>
Line 4,258:
to the list of character values.
 
<langsyntaxhighlight Ursalalang="ursala">#import std
#import nat
 
Line 4,265:
charval = -:@rlXS num alphabet
iprod = sum:-0+ product*p/weights+ charval*
checksum = difference/10+ remainder\10+ iprod</langsyntaxhighlight>
 
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.
<langsyntaxhighlight Ursalalang="ursala">weights = difference/*10 <1,3,1,7,3,9>
checksum = remainder\10+ iprod</langsyntaxhighlight>
 
A further performance improvement subsumes the character value lookup
Line 4,277:
the version shown below.
 
<langsyntaxhighlight Ursalalang="ursala">lookup = -: (^/~& product^|/~& charval)*lsPrK0/weights alphabet
iprod = sum:-0+ lookup*p/weights</langsyntaxhighlight>
 
To optimize further, we can build a separate smaller multiplication table for
Line 4,285:
index directly into the input list.
 
<langsyntaxhighlight Ursalalang="ursala">lookups = (-:+ * ^/~&l product^|/charval ~&)* *-* -*weights alphabet
iprod = sum:-0+ gang +^|(~&,~)*lNrXXK9 ^(~&,&h!)* lookups</langsyntaxhighlight>
Here is a test program.
<langsyntaxhighlight Ursalalang="ursala">#show+
 
examples = ^T(~&,~&h+ %nP+ checksum)*t
Line 4,302:
B0YBKR
585284
B0YBKT]-</langsyntaxhighlight>
output:
<pre>7108899
Line 4,316:
 
=={{header|VBA}}==
<langsyntaxhighlight lang="lb">Function getSedolCheckDigit(Input1)
Dim mult(6) As Integer
mult(1) = 1: mult(2) = 3: mult(3) = 1
Line 4,341:
getSedolCheckDigit = Input1 + CStr((10 - (Total Mod 10)) Mod 10)
End Function</langsyntaxhighlight>
 
=={{header|VBScript}}==
Derived from the BASIC version.
<syntaxhighlight lang="vbscript">
<lang VBScript>
arr = Array("710889",_
"B0YBKJ",_
Line 4,389:
Next
getSEDOLCheckDigit = (10 - total Mod 10) Mod 10
End Function</langsyntaxhighlight>
 
{{out}}
Line 4,407:
 
=={{header|Visual FoxPro}}==
<langsyntaxhighlight lang="vfp">
#DEFINE ALPHABET "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#DEFINE VOWELS "AEIOU"
Line 4,481:
RETURN EMPTY(tcMsg)
ENDFUNC
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 4,491:
{{libheader|Wren-str}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight lang="ecmascript">import "/str" for Char
import "/fmt" for Conv
 
Line 4,527:
var ans = (a = sedol.call(test)) ? a : "not valid"
System.print("%(test) -> %(ans)")
}</langsyntaxhighlight>
 
{{out}}
Line 4,545:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">string 0; \use zero-terminated strings
 
func CheckDigit(Str); \Return the check digit for a SEDOL
Line 4,584:
CrLf(0);
];
]</langsyntaxhighlight>
 
{{out}}
Line 4,602:
 
=={{header|Yabasic}}==
<langsyntaxhighlight Yabasiclang="yabasic">data "710889", "B0YBKJ", "406566", "B0YBLH", "228276", "B0YBKL", "557910", "B0YBKR", "585284", "B0YBKT", "B00030", "AB", "B00A03", ""
 
do
Line 4,627:
NEXT
return d$ + CHR$(48 + mod(10 - mod(s, 10), 10))
end sub</langsyntaxhighlight>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn checksum(text){
( text.len()!=6 or (text..matches("*[AEIOUaeioua-z]*")) ) and
throw(Exception.ValueError("Invalid SEDOL text: "+text));
Line 4,638:
else c.toAsc()-55;
}).zipWith('*,T(1,3,1,7,3,9)).sum() % 10) % 10;
}</langsyntaxhighlight>
It sure does look like that trailing %10 is extraneous. It also seems like lower case is implicitly invalid.
<langsyntaxhighlight lang="zkl">T("710889","B0YBKJ","406566","B0YBLH","228276",
"B0YBKL","557910","B0YBKR","585284","B0YBKT","B00030")
.apply(checksum).println();</langsyntaxhighlight>
{{out}}
<pre>
Thundergnat
10,327

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/328319"