Đề, đáp án thi học sinh giỏi tỉnh Yên Bái năm học 2020-2021

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

# Tạo danh sách chứa các số
numbers = [m, n, p, q]

# Sắp xếp danh sách
numbers.sort()

# Ghi kết quả ra tệp AGTMM.OUT
with open('AGTMM.OUT', 'w') as f:
    f.write(f"{numbers[0]} {numbers[-1]}")

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

int main() {
    ifstream infile("AGTMM.INP");
    ofstream outfile("AGTMM.OUT");

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

    // Tạo mảng chứa các số
    int numbers[] = {m, n, p, q};

    // Sắp xếp mảng
    sort(numbers, numbers + 4);

    // Ghi kết quả ra tệp AGTMM.OUT
    outfile << numbers[0] << " " << numbers[3];

    return 0;
}

var
  m, n, p, q, min_num, max_num: longint;
  infile, outfile: text;
  numbers: array[1..4] of longint;

begin
  assign(infile, 'AGTMM.INP');
  reset(infile);
  readln(infile, m, n, p, q);
  close(infile);

  // Lưu các số vào mảng
  numbers[1] := m;
  numbers[2] := n;
  numbers[3] := p;
  numbers[4] := q;

  // Sắp xếp mảng
  for var i := 1 to 3 do
    for var j := i + 1 to 4 do
      if numbers[i] > numbers[j] then
        begin
          var temp := numbers[i];
          numbers[i] := numbers[j];
          numbers[j] := temp;
        end;

  min_num := numbers[1];
  max_num := numbers[4];

  // Ghi kết quả ra tệp AGTMM.OUT
  assign(outfile, 'AGTMM.OUT');
  rewrite(outfile);
  writeln(outfile, min_num, ' ', max_num);
  close(outfile);
end.

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

# Sắp xếp mảng giảm dần
scores.sort(reverse=True)

# Tìm điểm cao nhất và số lượng học sinh đạt điểm cao nhất
max_score = scores[0]
num_max = scores.count(max_score)

# Tìm điểm cao thứ nhì và số lượng học sinh đạt điểm cao thứ nhì (nếu có)
second_max_score = None
num_second_max = 0

for score in scores:
    if score < max_score:
        second_max_score = score
        num_second_max = scores.count(score)
        break

# Ghi kết quả ra file
with open('BSORT.OUT', 'w') as f:
    f.write(f'{max_score} {num_max}\n')
    
    if second_max_score is not None:
        f.write(f'{second_max_score} {num_second_max}\n')
    else:
        f.write('NONE\n')

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

int main() {
    ifstream infile("BSORT.INP");
    ofstream outfile("BSORT.OUT");
    
    int n;
    infile >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        infile >> a[i];
    }

    // Tìm điểm cao nhất và số lượng học sinh đạt điểm cao nhất
    int max_score = *max_element(a.begin(), a.end());
    int count_max_score = count(a.begin(), a.end(), max_score);
    outfile << max_score << " " << count_max_score << endl;

    // Tìm điểm cao thứ nhì và số lượng học sinh đạt điểm cao thứ nhì
    int second_max_score = -1;
    int count_second_max_score = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] != max_score && a[i] > second_max_score) {
            second_max_score = a[i];
            count_second_max_score = 1;
        } else if (a[i] == second_max_score) {
            count_second_max_score++;
        }
    }
    if (count_second_max_score == 0) {
        outfile << "NONE";
    } else {
        outfile << second_max_score << " " << count_second_max_score;
    }

    infile.close();
    outfile.close();
    return 0;
}

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

int main() {
    ifstream infile("BSORT.INP");
    ofstream outfile("BSORT.OUT");
    
    int n;
    infile >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        infile >> a[i];
    }

    // Tìm điểm cao nhất và số lượng học sinh đạt điểm cao nhất
    int max_score = *max_element(a.begin(), a.end());
    int count_max_score = count(a.begin(), a.end(), max_score);
    outfile << max_score << " " << count_max_score << endl;

    // Tìm điểm cao thứ nhì và số lượng học sinh đạt điểm cao thứ nhì
    int second_max_score = -1;
    int count_second_max_score = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] != max_score && a[i] > second_max_score) {
            second_max_score = a[i];
            count_second_max_score = 1;
        } else if (a[i] == second_max_score) {
            count_second_max_score++;
        }
    }
    if (count_second_max_score == 0) {
        outfile << "NONE";
    } else {
        outfile << second_max_score << " " << count_second_max_score;
    }

    infile.close();
    outfile.close();
    return 0;
}

import math

def get_password(x):
    password = str(x)
    for i in range(1, int(math.sqrt(x))+1):
        if x % i == 0:
            password += str(i)
            if i != x // i:
                password += str(x // i)
    return password

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

# Tính mật mã cho từng nhân viên và ghi kết quả vào file
with open('CSPASS.OUT', 'w') as f:
    for i in range(n):
        password = get_password(a[i])
        f.write(password + ' ')

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

int main() {
    // Mở file input và output
    freopen("CSPASS.INP", "r", stdin);
    freopen("CSPASS.OUT", "w", stdout);

    int n;
    cin >> n;

    // Đọc dãy mã nhân viên và tìm các ước của mỗi mã
    vector<vector<int>> divisors(n);
    for (int i = 0; i < n; i++) {
        int a;
        cin >> a;
        for (int d = 1; d * d <= a; d++) {
            if (a % d == 0) {
                divisors[i].push_back(d);
                if (d != a / d) {
                    divisors[i].push_back(a / d);
                }
            }
        }
        sort(divisors[i].begin(), divisors[i].end());
    }

    // Tạo mật mã cho mỗi nhân viên
    for (int i = 0; i < n; i++) {
        int passcode = 0;
        for (int d : divisors[i]) {
            passcode = passcode * 10 + d;
        }
        cout << passcode << " ";
    }

    return 0;
}

program CSPASS;
var
  n, i, j: longint;
  a: array[1..1000] of longint;
begin
  // Mở file input để đọc dữ liệu
  assign(input, 'CSPASS.INP');
  reset(input);
  // Đọc dữ liệu
  readln(n);
  for i := 1 to n do
    readln(a[i]);
  // Đóng file input
  close(input);

  // Mở file output để ghi kết quả
  assign(output, 'CSPASS.OUT');
  rewrite(output);
  // Tính mật mã cho từng nhân viên và ghi kết quả
  for i := 1 to n do begin
    write(a[i]);
    for j := 1 to a[i] do
      if a[i] mod j = 0 then
        write(j);
    writeln;
  end;
  // Đóng file output
  close(output);
end.

# Đọc dữ liệu từ file input
with open('DSELECT.INP', 'r') as f:
    n, l, r = map(int, f.readline().split())
    a = []
    c = []
    for i in range(n):
        ai, ci = map(int, f.readline().split())
        a.append(ai)
        c.append(ci)

# Tính tổng giá trị lớn nhất của đồ vật được chọn
ans = 0
for i in range(l-1, r):
    for j in range(i, r):
        cur_weight = sum(c[i:j+1])
        if cur_weight <= r-l+1:
            cur_value = sum(a[i:j+1])
            if cur_value > ans:
                ans = cur_value

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

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

using namespace std;

// Khai báo cấu trúc đồ vật
struct Item {
    int value, weight;

    // Constructor
    Item(int v, int w) : value(v), weight(w) {}
};

// Hàm đọc dữ liệu từ file
void readData(vector<Item>& items, int& n, int& l, int& r) {
    ifstream inFile("DSELECT.INP");
    if (inFile.is_open()) {
        inFile >> n >> l >> r;
        for (int i = 0; i < n; i++) {
            int value, weight;
            inFile >> value >> weight;
            items.push_back(Item(value, weight));
        }
        inFile.close();
    }
}

// Hàm ghi kết quả vào file
void writeData(int result) {
    ofstream outFile("DSELECT.OUT");
    if (outFile.is_open()) {
        outFile << result;
        outFile.close();
    }
}

// Hàm tìm giá trị lớn nhất của một tập đồ vật có tổng trọng lượng nằm trong khoảng [l, r]
int knapsack(vector<Item>& items, int n, int l, int r) {
    int dp[r - l + 1] = {0}; // Khởi tạo mảng dp với giá trị mặc định là 0
    for (int i = 0; i < n; i++) {
        for (int j = r - items[i].weight; j >= l - items[i].weight; j--) {
            // Cập nhật giá trị lớn nhất của các tập đồ vật có tổng trọng lượng nằm trong khoảng [j + items[i].weight, j]
            if (j + items[i].weight <= r && j + items[i].weight >= l) {
                dp[j - l + items[i].weight] = max(dp[j - l + items[i].weight], dp[j - l] + items[i].value);
            }
        }
    }
    return dp[r - l];
}

int main() {
    int n, l, r;
    vector<Item> items;
    readData(items, n, l, r); // Đọc dữ liệu từ file
    int result = knapsack(items, n, l, r); // Tìm giá trị lớn nhất
    writeData(result); // Ghi kết quả vào file
    return 0;
}

const MAXN = 20;
var
  N, L, R, i, j, k: longint;
  a, c, dp: array[1..MAXN] of int64;
  f: text;

function max(a, b: int64): int64;
begin
  if a > b then max := a
  else max := b;
end;

begin
  // Đọc dữ liệu vào từ file
  assign(f, 'DSELECT.INP');
  reset(f);
  readln(f, N, L, R);
  for i := 1 to N do
    readln(f, a[i], c[i]);
  close(f);

  // Tính toán các giá trị trong mảng dp
  fillchar(dp, sizeof(dp), 0);
  for i := 1 to N do
  begin
    for j := i downto 1 do
    begin
      for k := j to i do
      begin
        if (c[k] >= L) and (c[k] <= i) then
          dp[i] := max(dp[i], dp[j-1] + a[k]);
      end;
    end;
  end;

  // Tìm giá trị lớn nhất trong mảng dp
  // và ghi kết quả ra file
  assign(f, 'DSELECT.OUT');
  rewrite(f);
  writeln(f, dp[N]);
  close(f);
end.