Đề thi HSG môn Tin học tỉnh Yên Bái năm học 2024 – 2025 (Có đáp án Full Code)

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main() {
    freopen("MATKHAU.INP", "r", stdin);
    freopen("MATKHAU.OUT", "w", stdout);

    string N; // Lưu số N dưới dạng chuỗi
    cin >> N;

    int M = 0; // Biến lưu tổng các chữ số
    for (char c : N) {
        M += (c - '0'); // Chuyển ký tự thành số và cộng vào tổng
    }

    cout << M; // Ghi kết quả ra file MATKHAU.OUT

    return 0;
}

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

// Hàm sàng Eratosthenes để tìm tất cả số nguyên tố <= maxP
vector<bool> sieve(int maxP) {
    vector<bool> isPrime(maxP + 1, true);
    isPrime[0] = isPrime[1] = false; // 0 và 1 không phải số nguyên tố
    for (int i = 2; i * i <= maxP; ++i) {
        if (isPrime[i]) {
            for (int j = i * i; j <= maxP; j += i) {
                isPrime[j] = false;
            }
        }
    }
    return isPrime;
}

int main() {
    freopen("SO3UOC.INP", "r", stdin);
    freopen("SO3UOC.OUT", "w", stdout);

    long long D, C;
    cin >> D >> C;

    // Giới hạn trên của p là sqrt(C)
    int maxP = sqrt(C);
    vector<bool> isPrime = sieve(maxP);

    int count = 0;
    for (int p = 2; p <= maxP; ++p) {
        if (isPrime[p]) {
            long long pSquare = (long long)p * p;
            if (pSquare >= D && pSquare <= C) {
                count++;
            }
        }
    }

    cout << count;

    return 0;
}

#include <iostream>
#include <string>
using namespace std;

int main() {
    freopen("SOTRANG.INP", "r", stdin);
    freopen("SOTRANG.OUT", "w", stdout);

    int N;
    cin >> N;

    // Mảng đếm số lần xuất hiện của các chữ số từ 0 đến 9
    int count[10] = {0};

    // Duyệt qua từng số từ 1 đến N
    for (int i = 1; i <= N; ++i) {
        int num = i;
        while (num > 0) {
            int digit = num % 10; // Lấy chữ số cuối cùng
            count[digit]++;
            num /= 10; // Loại bỏ chữ số cuối cùng
        }
    }

    // Ghi kết quả vào tệp SOTRANG.OUT 
    for (int i = 0; i < 10; ++i) {
        cout << i << " " << count[i] << endl;
    }

    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int main() {
    freopen("PTHUONG.INP", "r", stdin);
    freopen("PTHUONG.OUT", "w", stdout);

    int N, x;
    cin >> N >> x;

    vector<long long> a(N + 1); // Mảng lưu giá trị các phần thưởng
    for (int i = 1; i <= N; ++i) {
        cin >> a[i];
    }

    // Mảng dp để lưu tổng giá trị lớn nhất tại mỗi vị trí
    vector<long long> dp(N + 1, 0);

    // Biến max_prev để lưu giá trị lớn nhất của dp[j] trong khoảng [1, i-x]
    long long max_prev = 0;

    for (int i = 1; i <= N; ++i) {
        if (i > x) {
            max_prev = max(max_prev, dp[i - x]);
        }
        dp[i] = max(dp[i - 1], a[i] + max_prev);
    }

    // Kết quả là giá trị lớn nhất trong dp[N]
    cout << dp[N];

    return 0;
}

# Đọc dữ liệu từ file MATKHAU.INP
with open("MATKHAU.INP", "r") as f:
    N = f.read().strip()

# Tính tổng các chữ số của N
M = sum(int(digit) for digit in N)

# Ghi kết quả vào file MATKHAU.OUT
with open("MATKHAU.OUT", "w") as f:
    f.write(str(M))

import math

# Hàm sàng Eratosthenes để tìm các số nguyên tố <= maxP
def sieve(maxP):
    isPrime = [True] * (maxP + 1)
    isPrime[0] = isPrime[1] = False
    for i in range(2, int(math.sqrt(maxP)) + 1):
        if isPrime[i]:
            for j in range(i * i, maxP + 1, i):
                isPrime[j] = False
    return isPrime

# Đọc dữ liệu từ file SO3UOC.INP
with open("SO3UOC.INP", "r") as f:
    D, C = map(int, f.read().split())

# Giới hạn trên của p là sqrt(C)
maxP = int(math.sqrt(C))
isPrime = sieve(maxP)

# Đếm số lượng số có 3 ước số trong đoạn [D, C]
count = 0
for p in range(2, maxP + 1):
    if isPrime[p]:
        pSquare = p * p
        if D <= pSquare <= C:
            count += 1

# Ghi kết quả vào file SO3UOC.OUT
with open("SO3UOC.OUT", "w") as f:
    f.write(str(count))

# Đọc dữ liệu từ file SOTRANG.INP
with open("SOTRANG.INP", "r") as f:
    N = int(f.read())

# Khởi tạo mảng đếm số lần xuất hiện của các chữ số từ 0 đến 9
count = [0] * 10

# Duyệt qua từng số từ 1 đến N
for num in range(1, N + 1):
    while num > 0:
        digit = num % 10
        count[digit] += 1
        num //= 10

# Ghi kết quả vào file SOTRANG.OUT
with open("SOTRANG.OUT", "w") as f:
    for i in range(10):
        f.write(f"{i} {count[i]}\n")

# Đọc dữ liệu từ file PTHUONG.INP
with open("PTHUONG.INP", "r") as f:
    N, x = map(int, f.readline().split())
    a = list(map(int, f.readline().split()))

# Khởi tạo mảng dp và biến max_prev
dp = [0] * (N + 1)
max_prev = 0

# Tính toán dp[i] theo công thức quy hoạch động
for i in range(1, N + 1):
    if i > x:
        max_prev = max(max_prev, dp[i - x])
    dp[i] = max(dp[i - 1], a[i - 1] + max_prev)

# Ghi kết quả vào file PTHUONG.OUT
with open("PTHUONG.OUT", "w") as f:
    f.write(str(dp[N]))

program MatKhau;
var
  N: AnsiString;
  i, M: Integer;
  inputFile, outputFile: Text;
begin
  // Đọc dữ liệu từ file MATKHAU.INP
  Assign(inputFile, 'MATKHAU.INP');
  Reset(inputFile);
  ReadLn(inputFile, N);
  Close(inputFile);

  // Tính tổng các chữ số của N
  M := 0;
  for i := 1 to Length(N) do
    M := M + Ord(N[i]) - Ord('0');

  // Ghi kết quả vào file MATKHAU.OUT
  Assign(outputFile, 'MATKHAU.OUT');
  Rewrite(outputFile);
  WriteLn(outputFile, M);
  Close(outputFile);
end.

program SoCo3UocSo;
const
  MAX = 100000; // Giới hạn maxP = sqrt(10^9)
var
  isPrime: array[1..MAX] of Boolean;
  D, C, p, count, maxP: LongInt;
  inputFile, outputFile: Text;

procedure Sieve(maxP: LongInt);
var
  i, j: LongInt;
begin
  FillChar(isPrime, SizeOf(isPrime), True);
  isPrime[1] := False;
  for i := 2 to Trunc(Sqrt(maxP)) do
    if isPrime[i] then
      for j := i * i to maxP do
        if j mod i = 0 then
          isPrime[j] := False;
end;

begin
  // Đọc dữ liệu từ file SO3UOC.INP
  Assign(inputFile, 'SO3UOC.INP');
  Reset(inputFile);
  ReadLn(inputFile, D, C);
  Close(inputFile);

  // Giới hạn trên của p là sqrt(C)
  maxP := Trunc(Sqrt(C));
  Sieve(maxP);

  // Đếm số lượng số có 3 ước số trong đoạn [D, C]
  count := 0;
  for p := 2 to maxP do
    if isPrime[p] then
      if (p * p >= D) and (p * p <= C) then
        count := count + 1;

  // Ghi kết quả vào file SO3UOC.OUT
  Assign(outputFile, 'SO3UOC.OUT');
  Rewrite(outputFile);
  WriteLn(outputFile, count);
  Close(outputFile);
end.

program SoTrang;
var
  N, num, digit, i: LongInt;
  count: array[0..9] of LongInt;
  inputFile, outputFile: Text;
begin
  // Đọc dữ liệu từ file SOTRANG.INP
  Assign(inputFile, 'SOTRANG.INP');
  Reset(inputFile);
  ReadLn(inputFile, N);
  Close(inputFile);

  // Khởi tạo mảng đếm số lần xuất hiện của các chữ số từ 0 đến 9
  FillChar(count, SizeOf(count), 0);

  // Duyệt qua từng số từ 1 đến N
  for num := 1 to N do
  begin
    i := num;
    while i > 0 do
    begin
      digit := i mod 10;
      count[digit] := count[digit] + 1;
      i := i div 10;
    end;
  end;

  // Ghi kết quả vào file SOTRANG.OUT
  Assign(outputFile, 'SOTRANG.OUT');
  Rewrite(outputFile);
  for i := 0 to 9 do
    WriteLn(outputFile, i, ' ', count[i]);
  Close(outputFile);
end.

program PhanThuong;
const
  MAXN = 1000000; // Giới hạn N = 10^6
var
  N, x, i: LongInt;
  a: array[1..MAXN] of LongInt;
  dp: array[0..MAXN] of Int64;
  max_prev: Int64;
  inputFile, outputFile: Text;
begin
  // Đọc dữ liệu từ file PTHUONG.INP
  Assign(inputFile, 'PTHUONG.INP');
  Reset(inputFile);
  ReadLn(inputFile, N, x);
  for i := 1 to N do
    Read(inputFile, a[i]);
  Close(inputFile);

  // Khởi tạo mảng dp và biến max_prev
  dp[0] := 0;
  max_prev := 0;

  // Tính toán dp[i] theo công thức quy hoạch động
  for i := 1 to N do
  begin
    if i > x then
      max_prev := Max(max_prev, dp[i - x]);
    dp[i] := Max(dp[i - 1], a[i] + max_prev);
  end;

  // Ghi kết quả vào file PTHUONG.OUT
  Assign(outputFile, 'PTHUONG.OUT');
  Rewrite(outputFile);
  WriteLn(outputFile, dp[N]);
  Close(outputFile);
end.

import java.io.*;

public class MatKhau {
    public static void main(String[] args) throws IOException {
        // Đọc dữ liệu từ file MATKHAU.INP
        BufferedReader reader = new BufferedReader(new FileReader("MATKHAU.INP"));
        String N = reader.readLine().trim();
        reader.close();

        // Tính tổng các chữ số của N
        int M = 0;
        for (char c : N.toCharArray()) {
            M += Character.getNumericValue(c);
        }

        // Ghi kết quả vào file MATKHAU.OUT
        BufferedWriter writer = new BufferedWriter(new FileWriter("MATKHAU.OUT"));
        writer.write(Integer.toString(M));
        writer.close();
    }
}

import java.io.*;
import java.util.*;

public class SoCo3UocSo {
    public static void main(String[] args) throws IOException {
        // Đọc dữ liệu từ file SO3UOC.INP
        BufferedReader reader = new BufferedReader(new FileReader("SO3UOC.INP"));
        StringTokenizer st = new StringTokenizer(reader.readLine());
        long D = Long.parseLong(st.nextToken());
        long C = Long.parseLong(st.nextToken());
        reader.close();

        // Giới hạn trên của p là sqrt(C)
        int maxP = (int) Math.sqrt(C);
        boolean[] isPrime = new boolean[maxP + 1];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;

        // Sàng Eratosthenes
        for (int i = 2; i * i <= maxP; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= maxP; j += i) {
                    isPrime[j] = false;
                }
            }
        }

        // Đếm số lượng số có 3 ước số trong đoạn [D, C]
        int count = 0;
        for (int p = 2; p <= maxP; p++) {
            if (isPrime[p]) {
                long pSquare = (long) p * p;
                if (pSquare >= D && pSquare <= C) {
                    count++;
                }
            }
        }

        // Ghi kết quả vào file SO3UOC.OUT
        BufferedWriter writer = new BufferedWriter(new FileWriter("SO3UOC.OUT"));
        writer.write(Integer.toString(count));
        writer.close();
    }
}

import java.io.*;

public class SoTrang {
    public static void main(String[] args) throws IOException {
        // Đọc dữ liệu từ file SOTRANG.INP
        BufferedReader reader = new BufferedReader(new FileReader("SOTRANG.INP"));
        int N = Integer.parseInt(reader.readLine().trim());
        reader.close();

        // Khởi tạo mảng đếm số lần xuất hiện của các chữ số từ 0 đến 9
        int[] count = new int[10];

        // Duyệt qua từng số từ 1 đến N
        for (int num = 1; num <= N; num++) {
            int temp = num;
            while (temp > 0) {
                count[temp % 10]++;
                temp /= 10;
            }
        }

        // Ghi kết quả vào file SOTRANG.OUT
        BufferedWriter writer = new BufferedWriter(new FileWriter("SOTRANG.OUT"));
        for (int i = 0; i < 10; i++) {
            writer.write(i + " " + count[i] + "\n");
        }
        writer.close();
    }
}

import java.io.*;
import java.util.*;

public class PhanThuong {
    public static void main(String[] args) throws IOException {
        // Đọc dữ liệu từ file PTHUONG.INP
        BufferedReader reader = new BufferedReader(new FileReader("PTHUONG.INP"));
        StringTokenizer st = new StringTokenizer(reader.readLine());
        int N = Integer.parseInt(st.nextToken());
        int x = Integer.parseInt(st.nextToken());
        int[] a = new int[N];
        st = new StringTokenizer(reader.readLine());
        for (int i = 0; i < N; i++) {
            a[i] = Integer.parseInt(st.nextToken());
        }
        reader.close();

        // Khởi tạo mảng dp và biến max_prev
        long[] dp = new long[N + 1];
        long max_prev = 0;

        // Tính toán dp[i] theo công thức quy hoạch động
        for (int i = 1; i <= N; i++) {
            if (i > x) {
                max_prev = Math.max(max_prev, dp[i - x]);
            }
            dp[i] = Math.max(dp[i - 1], a[i - 1] + max_prev);
        }

        // Ghi kết quả vào file PTHUONG.OUT
        BufferedWriter writer = new BufferedWriter(new FileWriter("PTHUONG.OUT"));
        writer.write(Long.toString(dp[N]));
        writer.close();
    }
}