Đề thi học sinh giỏi môn Tin học thành phố Yên Bái năm học 2023-2024 (có đáp án)

#include <bits/stdc++.h>

using namespace std;
int a, b, c, d;
long long res1, res2, res3, res4, res;
int main()
{
    freopen("LARGESTA.INP", "r", stdin);
    freopen("LARGESTA.OUT", "w", stdout);
    cin >> a >> b >> c >> d;
    res1 = 1ll * a * b * c;
    res2 = 1ll * a * b * d;
    res3 = 1ll * a * c * d;
    res4 = 1ll * b * c * d;
    res = max(res1, max(res2,max(res3,res4)));
    cout << res;
    return 0;
}

# Đọc dữ liệu từ tệp vào
with open('LARGESTA.INP', 'r') as file_input:
    a, b, c, d = map(int, file_input.readline().split())

# Tìm tổ hợp có tích lớn nhất
max_product = max(a * b * c, a * b * d, a * c * d, b * c * d)

# Ghi kết quả vào tệp ra
with open('LARGESTA.OUT', 'w') as file_output:
    file_output.write(str(max_product))

#include <bits/stdc++.h>
#define nmax 100007
using namespace std;
int a[nmax], n;
int res = 1e9; // Khởi tạo res bằng giá trị lớn

void findMinimumDifference() {
    sort(a + 1, a + n + 1); // Sắp xếp mảng
    for(int i = 1; i < n; i++) {
        res = min(res, abs(a[i] - a[i + 1])); // Cập nhật res với độ chênh lệch nhỏ nhất
    }
}

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

    cin >> n;
    for(int i = 1; i <= n; i++) {
        cin >> a[i];
    }

    findMinimumDifference(); // Tìm độ chênh lệch nhỏ nhất
    cout << res;

    return 0;
}

# Đọc dữ liệu từ tệp vào
with open('SMADIFFE.INP', 'r') as file_input:
    # Đọc số lượng phần tử N
    N = int(file_input.readline().strip())

    # Đọc dãy số nguyên a
    a = list(map(int, file_input.readline().split()))

# Sắp xếp dãy số theo thứ tự tăng dần
a.sort()

# Tính độ chênh lệch nhỏ nhất giữa hai phần tử trong dãy
min_difference = float('inf')
for i in range(1, N):
    difference = abs(a[i] - a[i - 1])
    if difference < min_difference:
        min_difference = difference

# Ghi kết quả vào tệp ra
with open('SMADIFFE.OUT', 'w') as file_output:
    file_output.write(str(min_difference))

#include <bits/stdc++.h>
using namespace std;
long long n, tong, c[1000000], k = 0;
bool f[1000000];
void sangngto(long long n)                //Sàng Eratosthenes
{
    memset(f, true, sizeof(f));
    f[1] = false;
    int i = 2;
    while((i * i) <= n)
    {
        if(f[i])
        {
            int k = 2;
            while(i * k <= n)
            {
                f[i * k] = false;
                k++;
            }
            i++;
        }
        else
            i++;
    }
}
void thuasont(long long N)                 //Phân tích N thành tích thừa số nguyên tố
{                                                            // thu được mảng C có K phần tử kiểu long long (int64)  
    int i = 2;
    while(i * i <= N)
    {
        if(N % i == 0)
        {
            c[++k] = i;
            N /= i;
        }
        else
            i++;
    }
    if(N > 1)
        c[++k] = N;
}
void subtask3()           //Cách 3
{
    sangngto(n);                                 //Sàng Eratosthenes tới N
    for(int i = 1; i * i <= n; i++)
    {
        if(n % i == 0)
        {
            if(f[i])
                tong += i;
            if(i != n / i && f[n / i])
                tong += n / i;
        }
    }
    cout << tong;
}
void subtask4()               //Cách 4
{
    thuasont(n);              //phân tích N thành tích các thừa số nguyên tố
    tong = 0;
    for(int i = 1; i <= k; i++)      //tính tổng các thừa số nguyên tố khác nhau
        if(c[i] != c[i + 1])
            tong += c[i];
    cout << tong;
}

int main()
{
    ios_base::sync_with_stdio(false);
    freopen("suprimed.inp","r",stdin);
    freopen("suprimed.out","w",stdout);
    cin >> n;
    subtask4();  //gọi cách 4
    return 0;
}

def sieve_of_eratosthenes(n):
    prime = [True for _ in range(n+1)]
    p = 2
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * p, n+1, p):
                prime[i] = False
        p += 1
    return prime

def sum_of_prime_factors(n):
    prime = sieve_of_eratosthenes(n)
    sum_primes = 0
    for i in range(2, n + 1):
        if prime[i] and n % i == 0:
            sum_primes += i
    return sum_primes

def sum_of_unique_prime_factors(n):
    prime_factors = []
    i = 2
    while i * i <= n:
        if n % i == 0:
            prime_factors.append(i)
            while n % i == 0:
                n //= i
        i += 1
    if n > 1:
        prime_factors.append(n)

    return sum(set(prime_factors))

# Đọc dữ liệu từ file
with open("suprimed.inp", "r") as file:
    n = int(file.readline().strip())

# Tính tổng và ghi ra file
with open("suprimed.out", "w") as file:
    sum_primes = sum_of_unique_prime_factors(n)  
    file.write(str(sum_primes))

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100005;

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

    int n;
    cin >> n;
    vector<int> a(n);
    for (int &x : a) cin >> x;

    unordered_map<int, int> balance_index;
    balance_index[0] = -1;  // Khởi tạo với trường hợp cân bằng ban đầu
    int odd_count = 0, even_count = 0, max_len = 0;

    for (int i = 0; i < n; ++i) {
        if (a[i] % 2 == 0) even_count++;
        else odd_count++;

        int balance = odd_count - 2 * even_count;

        if (balance_index.find(balance) == balance_index.end()) {
            balance_index[balance] = i;
        } else {
            max_len = max(max_len, i - balance_index[balance]);
        }
    }

    if (max_len == 0) cout << "NONE";
    else cout << max_len;
    return 0;
}

def find_longest_subarray(nums):
    prefix_diff = 0
    max_length = 0
    last_seen = {0: -1}
    odd_count = 0
    even_count = 0

    for i, num in enumerate(nums):
        if num % 2 == 0:
            even_count += 1
        else:
            odd_count += 1

        prefix_diff = odd_count - 2 * even_count

        if prefix_diff in last_seen:
            max_length = max(max_length, i - last_seen[prefix_diff])
        else:
            last_seen[prefix_diff] = i

    return max_length

with open("LPARSEGM.INP", "r") as f:
    N = int(f.readline().strip())
    numbers = list(map(int, f.readline().split()))

result = find_longest_subarray(numbers)

with open("LPARSEGM.OUT", "w") as f_out:
    if result == 0:
        f_out.write("NONE")
    else:
        f_out.write(str(result))

#include <bits/stdc++.h>
#define nmax 100007
using namespace std;

int a[nmax], b[nmax];
long long n;
long long res = 0;
int k;
bool fre[nmax];

bool palin(long long u) {
    string su = to_string(u);
    string su0 = su;
    reverse(su.begin(), su.end());
    return (su0 == su);
}

void xuli() {
    long long s = 0;
    for (int i = 1; i <= k; i++)
        s = s * 10 + a[b[i]];
    if (palin(s))
        res = max(res, s);
}

void thu(int i) {
    for (int j = 1; j <= k; j++)
        if (fre[j]) {
            b[i] = j;
            fre[j] = false;
            if (i == k)
                xuli();
            else
                thu(i + 1);
            fre[j] = true;
        }
}

void subtask3() {
    memset(fre, true, sizeof(fre));
    thu(1);
}

void phantich(long long u) {
    k = 0;
    while (u > 0) {
        a[++k] = u % 10;
        u /= 10;
    }
}

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

    cin >> n;
    phantich(n);
    subtask3();
    cout << res;

    return 0;
}

from collections import Counter

def create_largest_palindrome(N):
    digit_count = Counter(str(N))
    first_half = []
    middle_digit = None

    for digit, count in digit_count.items():
        if count % 2 != 0:
            if not middle_digit or digit > middle_digit:
                middle_digit = digit

    for digit, count in digit_count.items():
        if digit == middle_digit:
            count -= 1
        first_half.extend([digit] * (count // 2))

    first_half.sort(reverse=True)

    if middle_digit:
        return int(''.join(first_half) + middle_digit + ''.join(first_half[::-1]))
    else:
        return int(''.join(first_half) + ''.join(first_half[::-1]))

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

# Tạo số đối xứng lớn nhất
largest_palindrome = create_largest_palindrome(N)

# Ghi kết quả vào file LSYMPERM.OUT
with open('LSYMPERM.OUT', 'w') as file:
    file.write(str(largest_palindrome))