Đề, đáp án thi học sinh giỏi thành phố Yên Bái năm học 2021-2022

with open('ASMIMA.INP', 'r') as f_input:
    m, n, p, q = map(int, f_input.readline().split())

lst = [m, n, p, q]
lst.sort(reverse=True)

max_sum = lst[0] + lst[1]
min_sum = lst[2] + lst[3]

with open('ASMIMA.OUT', 'w') as f_output:
    f_output.write('{} {}'.format(max_sum, min_sum))

#include <iostream>
#include <fstream>
#include <algorithm>

using namespace std;

int main() {
    ifstream fin("ASMIMA.INP");
    ofstream fout("ASMIMA.OUT");

    int m, n, p, q;
    fin >> m >> n >> p >> q;

    int lst[] = {m, n, p, q};
    sort(lst, lst+4, greater<int>());

    int max_sum = lst[0] + lst[1];
    int min_sum = lst[2] + lst[3];

    fout << max_sum << " " << min_sum;

    fin.close();
    fout.close();

    return 0;
}

program ASMIMA;
var
  f_input, f_output: TextFile;
  m, n, p, q, max_sum, min_sum: Integer;
  lst: array[1..4] of Integer;
  i: Integer;
begin
  AssignFile(f_input, 'ASMIMA.INP');
  Reset(f_input);
  ReadLn(f_input, m, n, p, q);
  CloseFile(f_input);

  lst[1] := m;
  lst[2] := n;
  lst[3] := p;
  lst[4] := q;
  for i := 1 to 4 do
    for j := i + 1 to 4 do
      if lst[i] < lst[j] then
      begin
        temp := lst[i];
        lst[i] := lst[j];
        lst[j] := temp;
      end;

  max_sum := lst[1] + lst[2];
  min_sum := lst[3] + lst[4];

  AssignFile(f_output, 'ASMIMA.OUT');
  Rewrite(f_output);
  Write(f_output, max_sum, ' ', min_sum);
  CloseFile(f_output);
end.

# Đọc dữ liệu vào từ file
with open('BSCH.INP', 'r') as f:
    n = int(f.readline().strip())
    a = list(map(int, f.readline().strip().split()))

# Xếp hàng tăng dần theo chiều cao
a_sort_inc = sorted(a)
print(*a_sort_inc)

# Xếp hàng giảm dần theo chiều cao
a_sort_dec = sorted(a, reverse=True)
print(*a_sort_dec)

# Tính độ chênh lệch chiều cao của bạn cao nhất và bạn thấp nhất
diff = a_sort_dec[0] - a_sort_inc[0]
print(diff)

# Ghi kết quả ra file
with open('BSCH.OUT', 'w') as f:
    f.write(' '.join(map(str, a_sort_inc)) + '\n')
    f.write(' '.join(map(str, a_sort_dec)) + '\n')
    f.write(str(diff))

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

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

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

    // Sap xep tang dan
    sort(a.begin(), a.end());
    for (int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
    cout << endl;

    // Sap xep giam dan
    sort(a.begin(), a.end(), greater<int>());
    for (int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
    cout << endl;

    // Tim do chenh lech
    int max_height = a[0];
    int min_height = a[n-1];
    cout << max_height - min_height << endl;

    return 0;
}

program BSCH;
var
  n, i, max_height, min_height: longint;
  a: array of longint;
begin
  Assign(input, 'BSCH.INP');
  Assign(output, 'BSCH.OUT');
  Reset(input);
  Rewrite(output);

  // Doc du lieu
  ReadLn(n);
  SetLength(a, n);
  for i := 0 to n-1 do
    Read(a[i]);

  // Sap xep tang dan
  for i := 0 to n-1 do
    Write(a[i], ' ');
  WriteLn;

  // Sap xep giam dan
  for i := n-1 downto 0 do
    Write(a[i], ' ');
  WriteLn;

  // Tim do chenh lech
  max_height := a[0];
  min_height := a[n-1];
  WriteLn(max_height - min_height);

  Close(input);
  Close(output);
end.

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

def is_palindrome(n):
    return str(n) == str(n)[::-1]

with open('CPPR.INP', 'r') as f_in, open('CPPR.OUT', 'w') as f_out:
    n = int(f_in.readline().strip())
    count = 0
    for i in range(2, n+1):
        if is_prime(i) and not is_palindrome(i):
            count += 1
    f_out.write(str(count))

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

// Hàm kiểm tra xem một số có phải là số Palindrome không
bool isPalindrome(int n) {
    int m = n, rev = 0;
    while (m > 0) {
        rev = rev * 10 + m % 10;
        m /= 10;
    }
    return (n == rev);
}

// Hàm kiểm tra xem một số có phải là số nguyên tố không
bool isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) return false;
    }
    return true;
}

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

    int n, count = 0;
    cin >> n;

    for (int i = 2; i <= n; i++) {
        if (isPrime(i) && !isPalindrome(i)) {
            count++;
        }
    }

    cout << count;

    return 0;
}

program palidrom;

var
  N, i, j, count: longint;

function isPrime(num: longint): boolean;
var
  i: longint;
begin
  if num < 2 then
    isPrime := false
  else if num = 2 then
    isPrime := true
  else if num mod 2 = 0 then
    isPrime := false
  else begin
    i := 3;
    while i <= trunc(sqrt(num)) do
    begin
      if num mod i = 0 then
      begin
        isPrime := false;
        exit;
      end;
      i := i + 2;
    end;
    isPrime := true;
  end;
end;

function isPalidrom(num: longint): boolean;
var
  reverse, original: longint;
begin
  original := num;
  reverse := 0;
  while num <> 0 do
  begin
    reverse := reverse * 10 + num mod 10;
    num := num div 10;
  end;
  if original = reverse then
    isPalidrom := true
  else
    isPalidrom := false;
end;

begin
  assign(input, 'CPPR.INP');
  assign(output, 'CPPR.OUT');
  reset(input);
  rewrite(output);

  readln(N);
  count := 0;
  for i := 2 to N do
  begin
    if (isPrime(i) = true) and (isPalidrom(i) = false) then
      count := count + 1;
  end;
  writeln(count);

  close(input);
  close(output);
end.

with open('DRSEL.INP', 'r') as f:
    n, r = map(int, f.readline().split())
    gifts = []
    for i in range(n):
        a, c = map(int, f.readline().split())
        gifts.append((a, c))

dp = [0] * (r+1)
for i in range(1, r+1):
    for a, c in gifts:
        if c <= i:
            dp[i] = max(dp[i], dp[i-c] + a)

with open('DRSEL.OUT', 'w') as f:
    f.write(str(dp[r]))

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

const int N = 20;

int n, r;
int a[N], c[N];
int dp[1 << N];

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

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

    for (int mask = 0; mask < (1 << n); mask++) {
        int total_c = 0, total_a = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                total_c += c[i];
                total_a += a[i];
            }
        }
        if (total_c <= r) {
            dp[mask] = total_a;
        }
    }

    for (int mask = 0; mask < (1 << n); mask++) {
        for (int i = 0; i < n; i++) {
            if (!(mask & (1 << i))) {
                dp[mask | (1 << i)] = max(dp[mask | (1 << i)], dp[mask] + a[i]);
            }
        }
    }

    cout << dp[(1 << n) - 1] << endl;
    return 0;
}

const
  MAXN = 20;
  MAXR = 1000000000;

var
  N, R, i, j: longint;
  a, c: array[1..MAXN] of longint;
  f: array[0..MAXR] of longint;

begin
  assign(input, 'DRSEL.INP'); reset(input);
  assign(output, 'DRSEL.OUT'); rewrite(output);

  readln(N, R);
  for i := 1 to N do
    readln(a[i], c[i]);

  fillchar(f, sizeof(f), 0);
  for i := 1 to N do
    for j := R downto c[i] do
      f[j] := max(f[j], f[j - c[i]] + a[i]);

  writeln(f[R]);

  close(input); close(output);
end.