'How to convert a UPC-E barcode to a UPC-A barcode?

What is the algorithm for converting a zero-suppressed, eight-digit GTIN-12 identifier (represented as a UPC-E barcode) into the full, twelve-digit version as shown in a UPC-A barcode?

barcode


Solution 1:[1]

The algorithm for converting a GTIN-12 identifier between UPC-E and UPC-A representation can be most clearly seen from the following pattern mapping:

SabcdeNX ? SabN0000cdeX  :  0?N?2
Sabcde3X ? Sabc00000deX
Sabcde4X ? Sabcd00000eX
SabcdeNX ? Sabcde0000NX  :  5?N?9

In the above S is the number system (either 0 or 1) and X is the check digit.

In pseudo-code it looks like this:

Input:  A valid eight-digit UPC-E: Assigned to E[]. 
Output: PASS: Twelve-digit UPC-A representing the UPC-E.
        FAIL: Reason.

if E[0] != {0-1} then FAIL: Invalid number system.

if E[6] == {0-2} then PASS: E[0..2] . E[6] . "0000"  . E[3..5] . E[7]
if E[6] == "3"   then PASS: E[0..3] .        "00000" . E[4..5] . E[7]
if E[6] == "4"   then PASS: E[0..4] .        "00000" . E[5]    . E[7]    
if E[6] == {5-9} then PASS: E[0..5] .        "0000"  . E[6]    . E[7]

Solution 2:[2]

This duplicates the algorithm in @Terry Burton's answer, written in Java.


switch (data.charAt(6)) {
    case '0':
    case '1':
    case '2': {
        data = data.substring(0, 3) + "0000" + data.charAt(6) + data.substring(3, 6) + data.charAt(7);
        break;
    }
    case '3': {
        data = data.substring(0, 4) + "00000" + data.substring(4, 5) + data.charAt(7);
        break;
    }
    case '4': {
        data = data.substring(0, 5) + "00000" + data.charAt(5) + data.charAt(7);
        break;
    }
    case '5':
    case '6':
    case '7':
    case '8':
    case '9': {
        data = data.substring(0, 6) + "0000" + data.charAt(6) + data.charAt(7);
        break;
    }
}

Solution 3:[3]

The Java code posted as a mistake in the 0-2 case. Here is a C# version that is corrected. As well as some test cases.

public string Expand_UPCE_to_UPCA_GTIN12(string upce)
{
    return upce[6] switch
    {
        '0' or '1' or '2' => $"{upce[..3]}{upce[6]}0000{upce[3..6]}{upce[7]}",
        '3' => $"{upce[..4]}00000{upce[4..6]}{upce[7]}",
        '4' => $"{upce[..5]}00000{upce[5]}{upce[7]}",
        _ => $"{upce[..6]}0000{upce[6..]}",
    };
}

Console.WriteLine($"Test A: {Expand_UPCE_to_UPCA_GTIN12("02345673")} becomes 023456000073");
Console.WriteLine($"Test B: {Expand_UPCE_to_UPCA_GTIN12("02345147")} becomes 023450000017");
Console.WriteLine($"Test C: {Expand_UPCE_to_UPCA_GTIN12("08679339")} becomes 086700000939");
Console.WriteLine($"Test D: {Expand_UPCE_to_UPCA_GTIN12("06397126")} becomes 063200009716");
Console.WriteLine($"Test E: {Expand_UPCE_to_UPCA_GTIN12("07832309")} becomes 078000003239"); // Diet Dr Pepper 12 fl oz can

Solution 4:[4]

Answer in Swift 5. Beware that this returns 0 if a conversion is not possible, so you'll need to change the code if you don't want that result. Extensions are included to make String index ranges much easier to use:

static func convertUPCEtoUPCA(code: String) -> String {
    if code.isNumber && code.length == 8
    {
        switch code[6] {
        case "0", "1", "2":
            return "\(code.prefix(3))\(String(code[6]))0000\(code[3..<6])\(String(code[7]))"
        case "3":
            return "\(code.prefix(4))00000\(code[4..<6])\(String(code[7]))"
        case "4":
            return "\(code.prefix(5))00000\(String(code[5]))\(String(code[7]))"
        case "5", "6", "7", "8", "9":
            return "\(code.prefix(6))0000\(code.suffix(2))"
        default:
            return "0"
        }
    } else {
        return "0"
    }
}

extension String {
    subscript(_ range: CountableRange<Int>) -> String {
        let start = index(startIndex, offsetBy: max(0, range.lowerBound))
        let end = index(start, offsetBy: min(self.count - range.lowerBound,
                                             range.upperBound - range.lowerBound))
        return String(self[start..<end])
    }
    
    subscript(_ range: CountablePartialRangeFrom<Int>) -> String {
        let start = index(startIndex, offsetBy: max(0, range.lowerBound))
        return String(self[start...])
    }
}

extension StringProtocol {
    subscript(offset: Int) -> Character {
        self[index(startIndex, offsetBy: offset)]
    }
}

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1
Solution 2
Solution 3
Solution 4 Ethan Allen

Related Questions