UPC: Difference between revisions

{{trans|Kotlin}}

 

‘ ## #’ = 0,

‘ ## #’ = 1,

 

L(barcode) barcodes

 

{{out}}

 

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

DEFINE RESOK="255"

DEFINE RESUPSIDEDOWN="254"

Test(i+1,codes(i))

OD

{{out}}

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

 

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

# number of digits encoded by UPC #

INT upc digits = 12;

FI

OD

{{out}}

<pre>

 

=={{header|AutoHotkey}}==

lBits :={" ## #":0," ## #":1," # ##":2," #### #":3," # ##":4," ## #":5," # ####":6," ### ##":7," ## ###":8," # ##":9}

xlBits:={"# ## ":0,"# ## ":1,"## # ":2,"# #### ":3,"## # ":4,"# ## ":5,"#### # ":6,"## ### ":7,"### ## ":8,"## # ":9}

return UPC

}

(

# # # ## # ## # ## ### ## ### ## #### # # # ## ## # # ## ## ### # ## ## ### # # #

output .= i ":`t" UPC2Dec(code) "`n"

MsgBox, 262144, ,% output

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f UPC.AWK

BEGIN {

return(sum)

}

{{out}}

<pre>

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

<pre> 1: 9 2 4 7 7 3 2 7 1 0 1 Valid

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

{{trans|Kotlin}}

#include <locale>

#include <map>

}

return 0;

{{out}}

<pre>[9, 2, 4, 7, 7, 3, 2, 7, 1, 0, 1, 9]

=={{header|D}}==

{{trans|C++}}

import std.array : array;

import std.conv : to;

];

barcodes.each!decodeUPC;

{{out}}

<pre>[9, 2, 4, 7, 7, 3, 2, 7, 1, 0, 1, 9]

=={{header|Factor}}==

{{works with|Factor|0.99 2019-10-06}}

kernel locals math math.functions math.vectors sequences

sequences.repeating unicode ;

" # # # #### ## # #### # # ## ## ### #### # # # # ### # ### ### # # ### # # # ### # # "

}

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

}

}

 

{{out}}

Implementation:

 

0 0 0 1 1 0 1 NB. 0

0 0 1 1 0 0 1 NB. 1

if. 10 e.digits do._ return.end.

if.0 ~:10|digits+/ .* 12$3 1 do._ return.end.

 

Here, we perform some basic integrity checks and use a table lookup to identify the decimal digits.

Task example:

 

# # # ## # ## # ## ### ## ### ## #### # # # ## ## # # ## ## ### # ## ## ### # # #

# # # ## ## # #### # # ## # ## # ## # # # ### # ### ## ## ### # # ### ### # # #

7 0 6 4 6 6 7 4 3 0 3 0

6 5 3 4 8 3 5 4 0 4 3 5

 

The row which begins with _ is the damaged row. (If rescanning did not fix that problem, the operator would have to enter the code manually.)

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.List;

import java.util.Map;

barcodes.forEach(UPC::decodeUPC);

}

{{out}}

<pre>[9, 2, 4, 7, 7, 3, 2, 7, 1, 0, 1, 9]

[7, 0, 6, 4, 6, 6, 7, 4, 3, 0, 3, 0]

[6, 5, 3, 4, 8, 3, 5, 4, 0, 4, 3, 5]</pre>

 

=={{header|Julia}}==

{{trans|Raku}}

" ## #", " # ####", " ### ##", " ## ###", " # ##")

const pat2 = [replace(x, r"[# ]" => (x) -> x == " " ? "#" : " ") for x in pat1]

(s = decodeUPC(reverse(line))) != "" ? s : "Invalid")

end

<pre>

924773271019

=={{header|Kotlin}}==

{{trans|C}}

" ## #" to 0,

" ## #" to 1,

decodeUPC(barcode)

}

{{out}}

<pre>[9, 2, 4, 7, 7, 3, 2, 7, 1, 0, 1, 9]

 

=={{header|Ksh}}==

 

# Find the corresponding UPC decimal representation of each, rejecting the error

fi

 

{{out}}

<pre> 9 2 4 7 7 3 2 7 1 0 1 9

 

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

# # # ## ## # #### # # ## # ## # ## # # # ### # ### ## ## ### # # ### ### # # #

# # # # # ### # # # # # # # # # # ## # ## # ## # ## # # #### ### ## # #

s//=Characters[StringSplit[#,"\n"]]&;

s=%/.{"#"->0," "->1};

{{out}}

<pre>{"924773271019", "403944441050", "834999676706", "939825158811", {}, "316313718717", "214575875608", "818778841813", "706466743030", "653483540435"}</pre>

=={{header|Nim}}==

{{trans|D}}

 

const

 

for barcode in BarCodes:

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

// 'Invalid';

}

{{out}}

<pre>924773271019

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(case Lst

((0 0 0 1 1 0 1) 0)

" # # # #### ## # #### # # ## ## ### #### # # # # ### # ### ### # # ### # # # ### # # " ) )

(for L (mapcar upc *U)

{{out}}

<pre>

 

=={{header|Python}}==

import itertools

import re

if __name__ == "__main__":

main()

 

{{out}}

=={{header|Racket}}==

 

 

;; inspired by Kotlin

" # # # ## # ## # ## ### ## ### ## #### # # # ## ## # # ## ## ### # ## ## ### # # # ")))

 

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

constant @patterns1 = ' ## #', ' ## #', ' # ##', ' #### #', ' # ##',

' ## #', ' # ####', ' ### ##', ' ## ###', ' # ##';

// decode_UPC($line.flip)

// 'Invalid';

 

{{out}}

 

=={{header|REXX}}==

#.0= ' ## #'

#.1= ' ## #'

if left(txt,1)\=="b" then if sum//10\==0 then txt= 'bad checksum' /*invalid sum? */

say center( strip(txt), 15) ' ' $$ /*show chksum (or err msg) with the UPC*/

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

<pre>

=={{header|Ruby}}==

{{trans|C}}

" ## #" => 0,

" ## #" => 1,

end

 

{{out}}

<pre> 1: [9, 2, 4, 7, 7, 3, 2, 7, 1, 0, 1, 9] Rightside Up

9: [7, 0, 6, 4, 6, 6, 7, 4, 3, 0, 3, 0] Rightside Up

10: [6, 5, 3, 4, 8, 3, 5, 4, 0, 4, 3, 5] Rightside Up</pre>

 

=={{header|Wren}}==

{{trans|Ruby}}

{{libheader|Wren-fmt}}

 

var digitL = {

Fmt.write("$2d: ", n)

decodeUpc.call(barcode)

 

{{out}}

 

=={{header|zkl}}==

[0..].zip(List(

"0 0 0 1 1 0 1", //--> "___##_#":0 "###__#_":0

if(tail!=barcode[idx,7]) return(Void); // 9 trailing blanks? two checked above

r

Or, if you like way too long regular expressions:

lhd.keys.concat("|","(",")")*6, "_#_#_",

rhd.keys.concat("|","(",")")*6, "#_#", "_"*9)),

upcRE.matched[1,*] // ( (a,b), "_#_####","_##___#", 10 more digit patterns )

.apply(digits.get)

#<<<"

_________#_#___#_##__#__##_#___##_###_##_###_##_####_#_#_#_##_##__#___#__##__##_###__#_##__##_###_#__#_#_________

bc:=parseBarCode(barcode);

println("%2d: [%s]".fmt(n,bc and bc.concat(" ") or "Not valid"));

{{out}}

<pre>