[Blue Bridge Cup-Übungen] Grundübungen: Hexadezimal bis Oktal (basierend auf der Java-Implementierung)

Ressourcenbeschränkungen

Zeitlimit: 1,0 s Speicherlimit: 512,0 MB

Problembeschreibung

Geben Sie bei n positiven hexadezimalen Ganzzahlen die entsprechenden Oktalzahlen aus.

Eingabeformat

Die erste Eingabezeile ist eine positive ganze Zahl n (1<=n<=10).
In den nächsten n Zeilen enthält jede Zeile eine Zeichenfolge bestehend aus 0 bis 9 und den Großbuchstaben A bis F, die die umzuwandelnde hexadezimale positive Ganzzahl angibt, und die Länge jeder Hexadezimalzahl überschreitet 100.000 nicht.

Ausgabeformat

Geben Sie n Zeilen aus, jede Zeile entspricht der oktalen positiven Ganzzahleingabe.

[Hinweis]
　　Die eingegebene Hexadezimalzahl hat keine 0 am Anfang, wie z. B. 012A.
　　Die ausgegebene Oktalzahl darf auch keine 0 am Anfang haben

import java.util.*;

public class hexadecimalToOctal
{
    
    
    public static String SixteenToEight(String str)
    {
    
    
        StringBuilder stringbuilder = new StringBuilder();
        char[] ch = str.toCharArray();
        for (char c :ch)
        {
    
    
            int temp;
            if (c >= 'A' && c <= 'F')
            {
    
    
                temp = c - 'A' + 10;
            } else
                temp = c - '0';
            // c - 'A'返回 ASCII码值

            Stack<Integer> stack = new Stack<>();
            // 利用栈先进后出的特点储存转换后的二进制
            for (int i = 0; i < 4; i++)
            {
    
    
                int n = temp % 2;
                temp = temp / 2;
                stack.push(n);
                // 每四位二进制对应一位十六进制
            }

            while (!stack.isEmpty())
            {
    
    
                stringbuilder.append(stack.pop());
            }

        }
        String result = stringbuilder.toString();
        return TwoToEight(result);
    }


    public static String TwoToEight(String str)
    {
    
    
        char[] ch = str.toCharArray();
        Stack<Integer> stack1 = new Stack<>();
        Stack<Integer> stack2 = new Stack<>();
        StringBuilder sb = new StringBuilder();

        for (int n = 0; n < 3 - ch.length % 3; n++)
        {
    
    
            stack1.push(0);
            // 每三位二进制对应一位八进制，不够补齐
        }
        for (char c : ch)
        {
    
    
            stack1.push(Integer.parseInt(String.valueOf(c)));
        }

        while (!stack1.isEmpty())
        {
    
    
            stack2.push(stack1.pop() + stack1.pop() * 2 + stack1.pop() * 4);
        }

        while(!stack2.isEmpty())
        {
    
    
            sb.append(stack2.pop());
        }
        
        char[] chars = sb.toString().toCharArray();
        int count = 0;
        // 对前导 0计数
        for(char c : chars)
        {
    
    
            if(c == '0')
            {
    
    
                count++;
            }
            else
                break;
        }
        char[] result = new char[chars.length-count];
        if (chars.length - count >= 0)
            System.arraycopy(chars, count, result, 0, chars.length - count);
        // 去除前导 0
        return String.valueOf(result);
    }

    public static void main(String[] args)
    {
    
    
        Scanner sr = new Scanner(System.in);
        int n = sr.nextInt();
        sr.nextLine();

        String[] A = new String[n];
        for(int i = 0;i < n;i++)
        {
    
    
            String temp = sr.nextLine();
            A[i] = temp;
        }
        sr.close();
        String[] result = new String[n];
        for(int i = 0;i < n;i++)
        {
    
    
            result[i] = SixteenToEight(A[i]);
            System.out.println(result[i]);
        }
    }
}