무게 변환기: 파운드, 킬로그램, 온스 및 그램 변환

1' 파운드를 킬로그램으로 변환
2=A1*0.45359237
3
4' 킬로그램을 파운드로 변환
5=A1*2.20462262
6
7' 온스를 그램으로 변환
8=A1*28.349523
9
10' 그램을 온스로 변환
11=A1*0.035273962
12
13' 범용 무게 변환 함수
14Function ConvertWeight(value, fromUnit, toUnit)
15    ' 그램(기본 단위)으로의 변환 계수
16    Select Case fromUnit
17        Case "lb": baseValue = value * 453.59237
18        Case "kg": baseValue = value * 1000
19        Case "oz": baseValue = value * 28.349523
20        Case "g": baseValue = value
21    End Select
22    
23    ' 그램에서 대상 단위로 변환
24    Select Case toUnit
25        Case "lb": ConvertWeight = baseValue / 453.59237
26        Case "kg": ConvertWeight = baseValue / 1000
27        Case "oz": ConvertWeight = baseValue / 28.349523
28        Case "g": ConvertWeight = baseValue
29    End Select
30End Function
31

1class WeightConverter:
2    def __init__(self):
3        # 그램(기본 단위)으로의 변환 계수
4        self.to_grams = {
5            'lb': 453.59237,
6            'kg': 1000.0,
7            'oz': 28.349523,
8            'g': 1.0
9        }
10        
11        # 그램에서의 변환 계수
12        self.from_grams = {
13            'lb': 1 / 453.59237,
14            'kg': 1 / 1000.0,
15            'oz': 1 / 28.349523,
16            'g': 1.0
17        }
18    
19    def convert(self, value, from_unit, to_unit):
20        if value < 0:
21            raise ValueError("무게는 음수일 수 없습니다")
22        
23        if from_unit not in self.to_grams:
24            raise ValueError(f"알 수 없는 단위: {from_unit}")
25        
26        if to_unit not in self.from_grams:
27            raise ValueError(f"알 수 없는 단위: {to_unit}")
28        
29        # 먼저 그램으로 변환한 후 대상 단위로 변환
30        grams = value * self.to_grams[from_unit]
31        result = grams * self.from_grams[to_unit]
32        
33        return round(result, 6)
34    
35    def convert_all(self, value, from_unit):
36        """모든 단위로 변환"""
37        results = {}
38        for unit in self.to_grams.keys():
39            if unit != from_unit:
40                results[unit] = self.convert(value, from_unit, unit)
41        return results
42
43# 사용 예시
44converter = WeightConverter()
45print(f"10 lbs = {converter.convert(10, 'lb', 'kg')} kg")
46print(f"5 kg = {converter.convert(5, 'kg', 'lb')} lbs")
47all_conversions = converter.convert_all(100, 'g')
48print(f"100g 변환 결과: {all_conversions}")
49

1class WeightConverter {
2    constructor() {
3        this.conversionFactors = {
4            // 그램으로의 변환 계수
5            toGrams: {
6                'lb': 453.59237,
7                'kg': 1000,
8                'oz': 28.349523,
9                'g': 1
10            },
11            // 그램에서의 변환 계수
12            fromGrams: {
13                'lb': 1 / 453.59237,
14                'kg': 1 / 1000,
15                'oz': 1 / 28.349523,
16                'g': 1
17            }
18        };
19    }
20    
21    convert(value, fromUnit, toUnit) {
22        // 입력 검증
23        if (isNaN(value) || value < 0) {
24            throw new Error('유효한 양수를 입력해 주세요');
25        }
26        
27        if (!this.conversionFactors.toGrams[fromUnit]) {
28            throw new Error(`알 수 없는 원본 단위: ${fromUnit}`);
29        }
30        
31        if (!this.conversionFactors.fromGrams[toUnit]) {
32            throw new Error(`알 수 없는 대상 단위: ${toUnit}`);
33        }
34        
35        // 중간 단위인 그램을 통해 변환
36        const grams = value * this.conversionFactors.toGrams[fromUnit];
37        const result = grams * this.conversionFactors.fromGrams[toUnit];
38        
39        // 적절한 정밀도로 반올림
40        return Math.round(result * 1000000) / 1000000;
41    }
42    
43    convertToAll(value, fromUnit) {
44        const results = {};
45        const units = ['lb', 'kg', 'oz', 'g'];
46        
47        units.forEach(unit => {
48            if (unit !== fromUnit) {
49                results[unit] = this.convert(value, fromUnit, unit);
50            }
51        });
52        
53        return results;
54    }
55}
56
57// 사용 예시
58const converter = new WeightConverter();
59console.log(`25 lbs = ${converter.convert(25, 'lb', 'kg')} kg`);
60console.log(`2 kg 변환 결과:`, converter.convertToAll(2, 'kg'));
61

1import java.math.BigDecimal;
2import java.math.RoundingMode;
3import java.util.HashMap;
4import java.util.Map;
5
6public class WeightConverter {
7    private static final Map<String, BigDecimal> TO_GRAMS = new HashMap<>();
8    private static final Map<String, BigDecimal> FROM_GRAMS = new HashMap<>();
9    
10    static {
11        // 그램으로의 변환 계수 초기화
12        TO_GRAMS.put("lb", new BigDecimal("453.59237"));
13        TO_GRAMS.put("kg", new BigDecimal("1000"));
14        TO_GRAMS.put("oz", new BigDecimal("28.349523"));
15        TO_GRAMS.put("g", BigDecimal.ONE);
16        
17        // 그램에서의 변환 계수 초기화
18        FROM_GRAMS.put("lb", BigDecimal.ONE.divide(TO_GRAMS.get("lb"), 10, RoundingMode.HALF_UP));
19        FROM_GRAMS.put("kg", new BigDecimal("0.001"));
20        FROM_GRAMS.put("oz", BigDecimal.ONE.divide(TO_GRAMS.get("oz"), 10, RoundingMode.HALF_UP));
21        FROM_GRAMS.put("g", BigDecimal.ONE);
22    }
23    
24    public static BigDecimal convert(BigDecimal value, String fromUnit, String toUnit) {
25        if (value.compareTo(BigDecimal.ZERO) < 0) {
26            throw new IllegalArgumentException("무게는 음수일 수 없습니다");
27        }
28        
29        if (!TO_GRAMS.containsKey(fromUnit)) {
30            throw new IllegalArgumentException("알 수 없는 원본 단위: " + fromUnit);
31        }
32        
33        if (!FROM_GRAMS.containsKey(toUnit)) {
34            throw new IllegalArgumentException("알 수 없는 대상 단위: " + toUnit);
35        }
36        
37        // 먼저 그램으로 변환
38        BigDecimal grams = value.multiply(TO_GRAMS.get(fromUnit));
39        
40        // 그램에서 대상 단위로 변환
41        BigDecimal result = grams.multiply(FROM_GRAMS.get(toUnit));
42        
43        return result.setScale(6, RoundingMode.HALF_UP);
44    }
45    
46    public static Map<String, BigDecimal> convertToAll(BigDecimal value, String fromUnit) {
47        Map<String, BigDecimal> results = new HashMap<>();
48        String[] units = {"lb", "kg", "oz", "g"};
49        
50        for (String unit : units) {
51            if (!unit.equals(fromUnit)) {
52                results.put(unit, convert(value, fromUnit, unit));
53            }
54        }
55        
56        return results;
57    }
58    
59    public static void main(String[] args) {
60        BigDecimal weight = new BigDecimal("15.5");
61        System.out.println("15.5 lbs = " + convert(weight, "lb", "kg") + " kg");
62        
63        Map<String, BigDecimal> allConversions = convertToAll(new BigDecimal("100"), "g");
64        System.out.println("100g 변환 결과: " + allConversions);
65    }
66}
67

1#include <iostream>
2#include <unordered_map>
3#include <string>
4#include <stdexcept>
5#include <iomanip>
6
7class WeightConverter {
8private:
9    std::unordered_map<std::string, double> toGrams;
10    std::unordered_map<std::string, double> fromGrams;
11    
12public:
13    WeightConverter() {
14        // 변환 계수 초기화
15        toGrams["lb"] = 453.59237;
16        toGrams["kg"] = 1000.0;
17        toGrams["oz"] = 28.349523;
18        toGrams["g"] = 1.0;
19        
20        fromGrams["lb"] = 1.0 / 453.59237;
21        fromGrams["kg"] = 0.001;
22        fromGrams["oz"] = 1.0 / 28.349523;
23        fromGrams["g"] = 1.0;
24    }
25    
26    double convert(double value, const std::string& fromUnit, const std::string& toUnit) {
27        if (value < 0) {
28            throw std::invalid_argument("무게는 음수일 수 없습니다");
29        }
30        
31        auto fromIt = toGrams.find(fromUnit);
32        if (fromIt == toGrams.end()) {
33            throw std::invalid_argument("알 수 없는 원본 단위: " + fromUnit);
34        }
35        
36        auto toIt = fromGrams.find(toUnit);
37        if (toIt == fromGrams.end()) {
38            throw std::invalid_argument("알 수 없는 대상 단위: " + toUnit);
39        }
40        
41        // 그램을 통해 변환
42        double grams = value * fromIt->second;
43        return grams * toIt->second;
44    }
45    
46    std::unordered_map<std::string, double> convertToAll(double value, const std::string& fromUnit) {
47        std::unordered_map<std::string, double> results;
48        std::vector<std::string> units = {"lb", "kg", "oz", "g"};
49        
50        for (const auto& unit : units) {
51            if (unit != fromUnit) {
52                results[unit] = convert(value, fromUnit, unit);
53            }
54        }
55        
56        return results;
57    }
58};
59
60int main() {
61    WeightConverter converter;
62    
63    try {
64        double result = converter.convert(10.0, "lb", "kg");
65        std::cout << std::fixed << std::setprecision(6);
66        std::cout << "10 lbs = " << result << " kg" << std::endl;
67        
68        auto allResults = converter.convertToAll(500.0, "g");
69        std::cout << "500g 변환 결과:" << std::endl;
70        for (const auto& pair : allResults) {
71            std::cout << "  " << pair.first << ": " << pair.second << std::endl;
72        }
73    } catch (const std::exception& e) {
74        std::cerr << "오류: " << e.what() << std::endl;
75    }
76    
77    return 0;
78}
79