補講：基本情報処理技術者試験 科目Bのアルゴリズム問題集

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;
        int ans = a * b + a;
        System.out.println(ans);
    }
}

public class Main {
    public static void main(String[] args) {
        int score = 75;
        String result = "不合格";
        if (score >= 80) {
            result = "優";
        } else if (score >= 60) {
            result = "良";
        } else {
            result = "不可";
        }
        System.out.println(result);
    }
}

public class Main {
    public static void main(String[] args) {
        int i = 1;
        int count = 0;
        while (i <= 10) {
            count = count + i;
            i = i + 3;
        }
        System.out.println(count);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40, 50};
        int total = 0;
        // Javaの配列は0番目から始まるため、
        // 擬似言語の「1から3まで」は「0から2まで」に対応します。
        for (int k = 0; k < 3; k++) { 
            total = total + nums[k];
        }
        System.out.println(total);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] scores = {70, 80, 90, 60, 100};
        int total = 0;
        for (int i = 0; i < scores.length; i++) {
            total = total + scores[i];
        }
        // 合計を実数（double）にキャストしてから割ることで、正確な平均を得られます
        double average = (double) total / scores.length;
        System.out.println(average);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] data = {15, 42, 7, 31, 24};
        // 最初の要素を暫定最大値とする
        int maxValue = data[0];
        // 2番目の要素（インデックス1）から順に比較する
        for (int i = 1; i < data.length; i++) {
            if (data[i] > maxValue) {
                maxValue = data[i];
            }
        }
        System.out.println(maxValue);
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 15; i++) {
            if (i % 15 == 0) {
                System.out.println("FizzBuzz");
            } else if (i % 3 == 0) {
                System.out.println("Fizz");
            } else if (i % 5 == 0) {
                System.out.println("Buzz");
            } else {
                System.out.println(i);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(checkValue(15));
    }
    public static String checkValue(int n) {
        // Javaでは「mod」の代わりに「%」、「and」の代わりに「&&」を使います
        if ((n % 3 == 0) && (n % 5 == 0)) {
            return "A";
        } else if (n % 3 == 0) {
            return "B";
        } else {
            return "C";
        }
    }
}

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] data = {1, 2, 3, 4, 5};
        int n = data.length;
        int temp;
        // Javaの添字は0〜(n-1)。
        // 擬似言語の「iを1から n/2」は、Javaでは「iを0から n/2 - 1」まで等の調整が必要ですが、
        // ここではロジックを分かりやすくJava風に書き直します。
        // 左端(i)と右端(n-1-i)を交換します。
        for (int i = 0; i < n / 2; i++) {
            temp = data[i];
            data[i] = data[n - 1 - i];
            data[n - 1 - i] = temp;
        }
        System.out.println(Arrays.toString(data));
    }
}

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int temp = arr[0]; // 先頭を退避
        for (int i = 0; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }
        arr[arr.length - 1] = temp; // 末尾に代入
        System.out.println(Arrays.toString(arr));
    }
}

public class Main {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= i; j++) {
                count = count + 1;
            }
        }
        System.out.println(count);
    }
}

public class Main {
    public static void main(String[] args) {
        int[][] mat = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int sum = 0;
        // Javaは0始まりなので、mat[i][i]でアクセスするために0から2まで回す
        for (int i = 0; i < 3; i++) {
            sum = sum + mat[i][i];
        }
        System.out.println(sum);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] freq = {10, 2, 8, 5, 15};
        int min1 = Integer.MAX_VALUE;
        int min2 = Integer.MAX_VALUE;

        for (int f : freq) {
            if (f < min1) {
                min2 = min1;
                min1 = f;
            } else if (f < min2) {
                min2 = f;
            }
        }
        System.out.println("最小1: " + min1 + ", 最小2: " + min2);
    }
}

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] nums = {4, 2, 5, 1, 3};
        // 外側のループ1回分 (i=0に対応)
        for (int j = nums.length - 1; j > 0; j--) {
            if (nums[j] < nums[j - 1]) {
                int temp = nums[j];
                nums[j] = nums[j - 1];
                nums[j - 1] = temp;
            }
        }
        System.out.println(Arrays.toString(nums));
    }
}

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] data = {4, 3, 1, 5, 2};
        int minIndex, temp;
        
        for (int i = 0; i < data.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < data.length; j++) {
                // Javaは0始まりですがロジックは同じ
                if (data[j] < data[minIndex]) {
                    minIndex = j;
                }
            }
            // 交換
            temp = data[i];
            data[i] = data[minIndex];
            data[minIndex] = temp;
        }
        System.out.println(Arrays.toString(data));
    }
}

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] cards = {10, 5, 8, 3, 6};
        // Javaでは i=1 が擬似言語の i=2 に相当
        for (int i = 1; i <= 2; i++) { // i=2(3番目の要素)まで実行
            int temp = cards[i];
            int j = i - 1;
            while (j >= 0 && cards[j] > temp) {
                cards[j + 1] = cards[j];
                j--;
            }
            cards[j + 1] = temp;
        }
        System.out.println(Arrays.toString(cards));
    }
}

public class Main {
    public static void main(String[] args) {
        int[] data = {10, 20, 30, 40, 50, 60, 70};
        System.out.println(binarySearch(data, 20));
    }
    public static int binarySearch(int[] data, int target) {
        int low = 0; // Javaは0始まり
        int high = data.length - 1;
        int middle;
        while (low <= high) {
            middle = (low + high) / 2;
            System.out.println("middle: " + middle); // 変化を確認
            if (data[middle] == target) {
                return middle;
            } else if (data[middle] < target) {
                low = middle + 1;
            } else {
                high = middle - 1;
            }
        }
        return -1;
    }
}

import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<Integer> stack = new ArrayList<>();
        
        stack.add(10); // push
        stack.add(20); // push
        
        int a = stack.remove(stack.size() - 1); // pop
        
        stack.add(30); // push
        stack.add(40); // push
        
        int b = stack.remove(stack.size() - 1); // pop
        int c = stack.remove(stack.size() - 1); // pop
        
        System.out.println(a + b - c);
    }
}

import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<Integer> queue = new ArrayList<>();
        
        queue.add(50); // enqueue (末尾に追加)
        queue.add(60); // enqueue
        
        int a = queue.remove(0); // dequeue (先頭の要素を取り出して削除)
        
        queue.add(70); // enqueue
        queue.add(80); // enqueue
        
        int b = queue.remove(0); // dequeue
        int c = queue.remove(0); // dequeue
        
        System.out.println(a + b - c);
    }
}

import java.util.PriorityQueue;

public class Main {
    public static void main(String[] args) {
        // JavaのPriorityQueueはデフォルトで昇順（小さい順）
        PriorityQueue<Integer> pq = new PriorityQueue<>();

        pq.enqueue(30);
        pq.enqueue(10);
        pq.enqueue(20);
        pq.poll(); // dequeueに相当（10が削除される）
        pq.enqueue(15);
        
        System.out.println(pq.poll()); // 15が出力される
    }
}

import java.util.Stack;
public class Main {
    public static void main(String[] args) {
        String[] tokens = {"3", "4", "+", "2", "*"};
        Stack<Integer> stack = new Stack<>();
        
        for (String token : tokens) {
            if (token.matches("\\d+")) {
                stack.push(Integer.parseInt(token));
            } else {
                int b = stack.pop();
                int a = stack.pop();
                if (token.equals("+")) stack.push(a + b);
                else if (token.equals("*")) stack.push(a * b);
            }
        }
        System.out.println(stack.pop());
    }
}

class ListElement {
    String val;
    ListElement next;
    ListElement(String val) { this.val = val; }
}
public class Main {
    public static void main(String[] args) {
        // リストの構築: Head -> A -> B -> C
        ListElement head = new ListElement("Head");
        ListElement a = new ListElement("A");
        ListElement b = new ListElement("B");
        ListElement c = new ListElement("C");
        
        head.next = a;
        a.next = b;
        b.next = c;
        
        // 削除処理
        ListElement p1 = head.next; // A
        ListElement p2 = p1.next;   // B
        p1.next = p2.next;          // A -> C
        
        // 結果確認
        System.out.println(head.next.val + " -> " + head.next.next.val);
    }
}

public class Main {
    public static void main(String[] args) {
        // インデックス0は使わず、1,2,3を使用すると仮定
        int[] next = {0, 2, 3, -1};
        int[] prev = {0, -1, 1, 2};
        
        int deleteIdx = 2;
        int p = prev[deleteIdx]; // 1
        int n = next[deleteIdx]; // 3
        
        if (p != -1) next[p] = n;
        if (n != -1) prev[n] = p;
        
        System.out.println(next[1]);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(sigma(3));
    }
    public static int sigma(int n) {
        if (n == 0) {
            return 0;
        }
        return n + sigma(n - 1);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(calc(24, 9));
    }
    public static int calc(int a, int b) {
        if (b == 0) {
            return a;
        }
        return calc(b, a % b);
    }
}

class Node {
    int val;
    Node left, right;
    Node(int val) { this.val = val; }
}
public class Main {
    public static void main(String[] args) {
        Node n1 = new Node(1);
        Node n2 = new Node(2);
        Node n3 = new Node(3);
        Node n4 = new Node(4);
        
        n1.left = n2; n1.right = n3;
        n2.left = n4;
        
        traverse(n1);
    }
    static void traverse(Node n) {
        if (n == null) return;
        traverse(n.left);
        System.out.println(n.val);
        traverse(n.right);
    }
}

class Node {
    int value;
    Node left, right;
    Node(int val) { this.value = val; }
}

public class Main {
    public static void main(String[] args) {
        // 木の構築（簡易版）
        Node root = new Node(10);
        root.left = new Node(5);
        root.right = new Node(15);
        root.left.right = new Node(8);
        root.left.right.left = new Node(7);

        int target = 7;
        Node current = root;

        while (current != null) {
            System.out.println(current.value);
            if (current.value == target) break;
            current = (target < current.value) ? current.left : current.right;
        }
    }
}

public class Main {
    static int[][] adj = {
        {},
        {2, 3},
        {4},
        {},
        {}
    };
    public static void main(String[] args) {
        visit(1);
    }
    public static void visit(int n) {
        System.out.println(n);
        for (int neighbor : adj[n]) {
            visit(neighbor);
        }
    }
}

import java.util.LinkedList;
import java.util.Queue;
public class Main {
    public static void main(String[] args) {
        int[][] adj = {
            {},
            {2, 3},
            {4, 5},
            {6},
            {}, {}, {}
        };
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        
        while (!queue.isEmpty()) {
            int n = queue.poll();
            System.out.println(n);
            for (int neighbor : adj[n]) {
                queue.add(neighbor);
            }
        }
    }
}

import java.util.ArrayList;
import java.util.List;
public class Main {
    // 1始まりのインデックスを模倣するためにダミー要素を入れる
    static List<Integer> heap = new ArrayList<>();
    
    public static void main(String[] args) {
        heap.add(0); // index 0 (dummy)
        int[] data = {10, 30, 20, 5, 40};
        for (int val : data) {
            pushHeap(val);
        }
        System.out.println(heap.get(1)); // 根を出力
    }
    public static void pushHeap(int val) {
        heap.add(val);
        int k = heap.size() - 1;
        while (k > 1 && heap.get(k) > heap.get(k / 2)) {
            int parent = k / 2;
            int temp = heap.get(k);
            heap.set(k, heap.get(parent));
            heap.set(parent, temp);
            k = parent;
        }
    }
}

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] table = new int[10];
        Arrays.fill(table, -1);
        int[] data = {15, 25, 35};
        int finalPos = -1;
        for (int x : data) {
            int pos = x % 10;
            while (table[pos] != -1) {
                pos = (pos + 1) % 10;
            }
            table[pos] = x;
            if (x == 35) finalPos = pos;
        }
        System.out.println(finalPos);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] arrA = {2, 5, 9};
        int[] arrB = {1, 6, 8};
        int[] arrC = new int[6];
        int a = 0, b = 0, c = 0;
        // 擬似言語の1始まりを0始まりに読み替え
        while (a < arrA.length && b < arrB.length) {
            if (arrA[a] < arrB[b]) {
                arrC[c++] = arrA[a++];
            } else {
                arrC[c++] = arrB[b++];
            }
        }
        // Java配列は0から始まるため、4番目はインデックス3
        System.out.println(arrC[3]); 
    }
}

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] data = {2, 6, 1, 7, 4};
        int pivot = data[data.length - 1]; // pivot = 4
        int i = -1; // Javaは0始まりなので、擬似言語の0に対応するのは-1
        for (int j = 0; j < data.length - 1; j++) {
            if (data[j] < pivot) {
                i++;
                int temp = data[i];
                data[i] = data[j];
                data[j] = temp;
            }
        }
        // ピボットの移動
        int temp = data[i + 1];
        data[i + 1] = data[data.length - 1];
        data[data.length - 1] = temp;
        System.out.println(Arrays.toString(data));
    }
}

public class Main {
    public static void main(String[] args) {
        int[] array = {3, 5, 2, 3, 1};
        int[] bucket = new int[6]; // 1〜5を使用するためサイズ6を確保

        // 出現回数をカウント
        for (int value : array) {
            bucket[value]++;
        }

        // 元の配列に書き戻す
        int k = 0;
        for (int i = 1; i <= 5; i++) {
            while (bucket[i] > 0) {
                array[k++] = i;
                bucket[i]--;
            }
        }
        
        for (int n : array) System.out.print(n + " ");
    }
}

public class Main {
    public static void main(String[] args) {
        int[] data = {3, 1, 4, 1, 5};
        // 出現した数字を記録する（1〜9を想定して10個の領域を確保）
        boolean[] checked = new boolean[10];
        boolean hasDuplicate = false;

        for (int i = 0; i < data.length; i++) {
            int val = data[i];
            if (checked[val]) {
                hasDuplicate = true;
                break; // 重複が見つかった時点で終了
            }
            checked[val] = true;
        }
        System.out.println(hasDuplicate);
    }
}

public class Main {
    public static void main(String[] args) {
        String text = "BABABABC";
        String pattern = "ABC";
        int n = text.length();
        int m = pattern.length();
        boolean match = false;
        int foundIndex = -1;
        for (int i = 0; i <= n - m; i++) {
            match = true;
            for (int j = 0; j < m; j++) {
                if (text.charAt(i + j) != pattern.charAt(j)) {
                    match = false;
                    break;
                }
            }
            if (match) {
                foundIndex = i + 1; // 1始まりに合わせる
                break;
            }
        }
        System.out.println(foundIndex);
    }
}

public class Main {
    public static void main(String[] args) {
        String s = "AAABCCCC";
        String res = "";
        int count = 1;
        for (int i = 0; i < s.length() - 1; i++) {
            if (s.charAt(i) == s.charAt(i + 1)) {
                count++;
            } else {
                res = res + s.charAt(i) + count;
                count = 1;
            }
        }
        // 最後の部分を追加
        res = res + s.charAt(s.length() - 1) + count;
        System.out.println(res);
    }
}

public class Main {
    public static void main(String[] args) {
        char[] targetStr = {'A', 'B', 'C', 'D', 'B', 'C'};
        char[] searchWord = {'B', 'C'};
        char replaceChar = 'X';

        for (int i = 0; i < targetStr.length - 1; i++) {
            // 現在の文字と次の文字が検索語と一致するか
            if (targetStr[i] == searchWord[0] && targetStr[i+1] == searchWord[1]) {
                targetStr[i] = replaceChar;
                targetStr[i+1] = ' '; // 2文字目を空文字扱いに
            }
        }
        System.out.println(new String(targetStr));
    }
}

public class Main {
    public static void main(String[] args) {
        int a = 6;
        int b = 32;
        // 左に2ビットシフト（4倍）
        a = a << 2;
        // 右に3ビットシフト（1/8倍）
        b = b >> 3;
        int value = a + b;
        System.out.println(value);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(getBit(20, 3));
    }
    static int getBit(int val, int n) {
        int mask = 1;
        mask = mask << (n - 1);
        
        if ((val & mask) != 0) {
            return 1;
        } else {
            return 0;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int a = 10; // 1010
        int b = 6;  // 0110
        
        int temp = a ^ b; // 1100 (12)
        a = temp;
        
        temp = a ^ b; // 1100 ^ 0110 = 1010 (10)
        
        System.out.println(temp);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] data = {1, 0, 1, 1, 0, 0, 1};
        int sum = 0;
        for (int bit : data) {
            sum += bit;
        }
        int parity;
        if (sum % 2 == 0) {
            parity = 0;
        } else {
            parity = 1;
        }
        System.out.println(parity);
    }
}

class Counter {
    int count;
    Counter() { count = 0; }
    void add(int n) { count += n; }
    void clear() { count = 0; }
}
public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        
        c1.add(5);
        c2.add(10);
        c1.add(3);
        c2.clear();
        c2.add(2);
        
        System.out.println(c1.count + c2.count);
    }
}

public class Main {
    public static void main(String[] args) {
        double x1 = 1.0, y1 = 1.0;
        double x2 = 4.0, y2 = 5.0;

        double dx = x2 - x1;
        double dy = y2 - y1;

        // Math.sqrtは平方根、Math.pow(n, 2)は2乗を求めます
        double distance = Math.sqrt(dx * dx + dy * dy);

        System.out.println(distance);
    }
}

public class Main {
    static int[] scores = {0, 0, 0, 5, 3, 8, 1}; // index 0~6
    public static void main(String[] args) {
        System.out.println(minimax(0, true));
    }
    public static int minimax(int node, boolean isMax) {
        // 簡易的な判定：配列外なら終了とみなす等の処理が必要だが
        // ここでは問題文の通りnode>=3で葉とする
        if (node >= 3) {
            return scores[node];
        }
        if (isMax) {
            int left = minimax(2 * node + 1, false);
            int right = minimax(2 * node + 2, false);
            return Math.max(left, right);
        } else {
            int left = minimax(2 * node + 1, true);
            int right = minimax(2 * node + 2, true);
            return Math.min(left, right);
        }
    }
}