Đề, Đáp án thi Tin học trẻ thành phố Yên Bái năm 2023

import math

# Đọc dữ liệu từ tệp PASS.INP
with open('PASS.INP', 'r') as f:
    n = int(f.readline().strip())

# Tìm ước số nguyên tố và tổng ước của N
prime_factors = set()
sum_factors = 1 # chứa ước số 1
for i in range(2, int(math.sqrt(n))+1):
    if n % i == 0:
        prime_factors.add(i)
        prime_factors.add(n//i)
        sum_factors += i + n//i
if math.sqrt(n) % 1 == 0: # n là số chính phương
    prime_factors.add(int(math.sqrt(n)))
    sum_factors += int(math.sqrt(n))

# Điều chỉnh khóa số K1 và K2
k1 = len(prime_factors)
k2 = sum_factors

# Ghi kết quả ra tệp PASS.OUT
with open('PASS.OUT', 'w') as f:
    f.write(f"{k1} {k2}")

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

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

    int n;
    cin >> n;

    // Tìm ước số nguyên tố và tổng ước của N
    set<int> prime_factors;
    int sum_factors = 1; // chứa ước số 1
    for (int i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) {
            prime_factors.insert(i);
            prime_factors.insert(n/i);
            sum_factors += i + n/i;
        }
    }
    if (sqrt(n) == floor(sqrt(n))) { // n là số chính phương
        prime_factors.insert(sqrt(n));
        sum_factors += sqrt(n);
    }

    // Điều chỉnh khóa số K1 và K2
    int k1 = prime_factors.size();
    int k2 = sum_factors;

    // Ghi kết quả ra tệp PASS.OUT
    cout << k1 << " " << k2;

    return 0;
}

program unlockTreasure;
var
  n, i, K1, K2, sum: longint;
  f: text;
begin
  assign(f, 'PASS.INP');
  reset(f);
  readln(f, n);
  close(f);
  
  K1 := 0;
  for i := 1 to n do
    if n mod i = 0 then
      if (i = 1) or (i = n) then
        inc(K1);
  
  K2 := 0;
  for i := 1 to n do
    if n mod i = 0 then
      inc(K2, i);
  
  assign(f, 'PASS.OUT');
  rewrite(f);
  writeln(f, K1);
  writeln(f, K2);
  close(f);
end.

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

# Tính toán phạm vi liên tiếp có tổng lớn nhất
start, end = 0, 0
max_sum = a[0]
cur_sum = a[0]
for i in range(1, n):
    if cur_sum < 0:
        cur_sum = 0
        start = i
    cur_sum += a[i]
    if cur_sum > max_sum:
        max_sum = cur_sum
        end = i

# Ghi kết quả vào file
with open("DOANCON.OUT", "w") as f:
    f.write(str(end - start + 1))

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

const int MAXN = 1e5 + 5;

int n, a[MAXN];
int dp1[MAXN], dp2[MAXN];

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

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

    // tính dp1
    dp1[1] = 1;
    for (int i = 2; i <= n; i++) {
        if (a[i] >= a[i - 1]) {
            dp1[i] = dp1[i - 1] + 1;
        } else {
            dp1[i] = 1;
        }
    }

    // tính dp2
    dp2[n] = 1;
    for (int i = n - 1; i >= 1; i--) {
        if (a[i] <= a[i + 1]) {
            dp2[i] = dp2[i + 1] + 1;
        } else {
            dp2[i] = 1;
        }
    }

    // tìm kết quả
    int res = 1;
    for (int i = 2; i <= n; i++) {
        if (a[i] > a[i - 2]) {
            res = max(res, dp1[i - 1] + dp2[i]);
        }
    }

    cout << res << endl;

    return 0;
}

program doancon;
const
  MAXN = 100000;
var
  n, res, l, r: longint;
  a: array[1..MAXN] of longint;
  fmax, fmin, max1, max2, min1, min2: array[0..MAXN] of longint;
  fin, fout: text;
  
procedure readInput;
var
  i: longint;
begin
  assign(fin, 'DOANCON.INP');
  reset(fin);
  readln(fin, n);
  for i := 1 to n do
    read(fin, a[i]);
  close(fin);
end;

procedure writeOutput(res: longint);
begin
  assign(fout, 'DOANCON.OUT');
  rewrite(fout);
  write(fout, res);
  close(fout);
end;

procedure DP;
var
  i: longint;
begin
  fmax[0] := 0;
  fmin[0] := 0;
  max1[0] := 0;
  max2[n+1] := 0;
  min1[0] := 0;
  min2[n+1] := 0;
  for i := 1 to n do
  begin
    max1[i] := max(max1[i-1] + a[i], 0);
    max2[n-i+1] := max(max2[n-i+2] + a[n-i+1], 0);
    min1[i] := min(min1[i-1] + a[i], 0);
    min2[n-i+1] := min(min2[n-i+2] + a[n-i+1], 0);
    fmax[i] := max(max(fmax[i-1], max1[i]), max2[i]);
    fmin[i] := min(min(fmin[i-1], min1[i]), min2[i]);
  end;
  res := n;
  l := 1;
  r := 1;
  while (r <= n) do
  begin
    while (r <= n) and (fmax[r] - fmin[r] <= 1) do 
      Inc(r);
    res := min(res, r - l);
    Inc(l);
  end;
end;

begin
  readInput;
  DP;
  writeOutput(res);
end.

# Đọc dữ liệu vào từ file MK.INP
with open('MK.INP', 'r') as f:
    password = f.readline().strip()
    weight_of_a = int(f.readline())

# Tính trọng số của các ký tự và lưu vào mảng tĩnh weights
weights = [(weight_of_a + i) % 26 for i in range(26)]

# Tính tổng trọng số của mật khẩu
strength = sum(weights[ord(c) - ord('a')] for c in password)

# Ghi kết quả ra file MK.OUT
with open('MK.OUT', 'w') as f:
    f.write(str(strength))

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

int main() {
    // Mở file input và output bằng hàm freopen
    freopen("MK.INP", "r", stdin);
    freopen("MK.OUT", "w", stdout);

    string password;
    int weight_of_a;

    // Đọc dữ liệu vào
    cin >> password >> weight_of_a;

    // Tính trọng số của các ký tự và lưu vào mảng tĩnh weights
    vector<int> weights(26);
    for (int i = 0; i < 26; i++) {
        weights[i] = (weight_of_a + i) % 26;
    }

    // Tính độ mạnh của mật khẩu
    int strength = 0;
    for (char c : password) {
        strength += weights[c - 'a'];
    }

    // Ghi kết quả ra file MK.OUT
    cout << strength << endl;

    return 0;
}

var
  f: text;
  password: string;
  weight_of_a, i, strength: integer;
  weights: array[0..25] of integer;

begin
  // Mở file input và output
  assign(f, 'MK.INP');
  reset(f);
  assign(output, 'MK.OUT');
  rewrite(output);
  reset(output);

  // Đọc dữ liệu vào
  readln(f, password);
  readln(f, weight_of_a);

  // Tính trọng số của các ký tự và lưu vào mảng tĩnh weights
  for i := 0 to 25 do begin
    weights[i] := (weight_of_a + i) mod 26;
  end;

  // Tính độ mạnh của mật khẩu
  strength := 0;
  for i := 1 to length(password) do begin
    strength := strength + weights[ord(password[i]) - ord('a')];
  end;

  // Ghi kết quả ra file MK.OUT
  writeln(strength);

  // Đóng file input và output
  close(f);
  close(output);
end.

def reward(n, s, a):
    # Khởi tạo mảng dp có kích thước (n+1)x(n+1) và giá trị ban đầu đều là 0
    dp = [[0 for j in range(n+1)] for i in range(n+1)]
    
    # Khởi tạo biến count để đếm số lượng cách lựa chọn phần thưởng thỏa mãn yêu cầu
    count = 0
    
    # Duyệt tất cả các cặp (i, j) với 1 <= i <= j <= n
    for i in range(1, n+1):
        for j in range(i, n+1):
            # Cập nhật giá trị của dp[i][j] bằng tổng giá trị các vật liên tiếp từ số hiệu i đến j
            dp[i][j] = dp[i][j-1] + a[j]
            
            # Nếu tổng giá trị các vật từ i đến j lớn hơn giá trị S
            if abs(dp[i][j]) > s:
                # Tăng biến count lên 1
                count += 1
                
                # Duyệt tất cả các cặp (x, y) với i <= x <= y <= j
                for x in range(i, j+1):
                    for y in range(x, j+1):
                        # Nếu tổng giá trị các vật từ x đến y lớn hơn giá trị S
                        if abs(dp[x][y]) > s:
                            # Giảm biến count đi 1
                            count -= 1
    
    # Trả về số lượng cách lựa chọn phần thưởng thỏa mãn yêu cầu
    return count


# Hàm đọc dữ liệu từ file và trả về giá trị tương ứng của N, S và mảng a
def read_input(file_path):
    with open(file_path, 'r') as f:
        n, s = map(int, f.readline().split())
        a = list(map(int, f.readline().split()))
        return n, s, a


# Hàm ghi kết quả vào file
def write_output(file_path, result):
    with open(file_path, 'w') as f:
        f.write(str(result))


# Đọc dữ liệu từ file input.txt
n, s, a = read_input('ASUM.INP')

# Tính số lượng cách lựa chọn phần thưởng thỏa mãn yêu cầu
count = reward(n, s, a)

# Ghi kết quả vào file output.txt
write_output('ASUM.OUT', count)

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

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

    // Đọc dữ liệu
    int n, s;
    cin >> n >> s;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }

    // Tính số lượng cách lựa chọn phần thưởng thỏa mãn điều kiện
    int ans = 0;
    vector<int> f(n + 1);
    f[1] = abs(a[1]);
    if (f[1] >= abs(s)) {
        ans++;
    }
    for (int i = 2; i <= n; i++) {
        f[i] = abs(a[i]);
        for (int j = i - 1; j >= 1; j--) {
            f[j] += abs(a[i]);
            if (f[j] >= abs(s)) {
                ans += i - j;
            }
        }
        if (f[i] >= abs(s)) {
            ans++;
        }
    }

    // Ghi kết quả vào file output
    cout << ans << endl;

    return 0;
}

program asum;

const
  MAX_N = 100000;
  MAX_S = 100000;

var
  N, S: integer;
  a: array[1..MAX_N] of integer;
  f: array[0..MAX_N] of int64;
  g: array[0..MAX_N] of int64;
  i, j: integer;
  cnt: int64;
  inp, out: text;

begin
  assign(inp, 'ASUM.INP');
  assign(out, 'ASUM.OUT');
  reset(inp);
  rewrite(out);

  readln(inp, N, S);
  for i := 1 to N do
    read(inp, a[i]);

  f[0] := 0;
  g[0] := 1;
  cnt := 0;

  for i := 1 to N do begin
    f[i] := f[i-1] + a[i];
    g[i] := g[i-1];
    while (f[i] - f[j-1] > S) and (j <= i) do begin
      g[i] := g[i] - g[j-1];
      f[i] := f[i] - a[j];
      j := j + 1;
    end;
    if f[i] - f[j-1] = S then
      cnt := cnt + g[j-1];
  end;

  writeln(out, cnt);

  close(inp);
  close(out);
end.