Вспомним, что механическое движение – это изменение положения тела относительно других тел с течением времени.

Если мы свяжем с любым телом свою систему координат, то любое тело можно считать за ТО, значит одно и то же тело может занимать различное положение относительно других тел. Например, положение ручки на столе различное относительно стола и двери.

Но относительно не только положение, но и движение. Например, пассажир в стоящем поезде полагает, что он движется если будет смотреть в окно на движущийся поезд. А на самом деле он движется относительно поезда, но не относительно земли.

Поскольку, скорость – это характеристика движения, то и она также относительна. А что нам даёт относительное движение и относительная скорость?

Пусть есть неподвижная СО, например земля, пусть есть другая подвижная СО, которая движется относительно неподвижной и нам известно её движение (мы знаем её скорость и направление). Мы можем, находясь в неподвижной СО, определить движение тела относительно движущейся СО.

Или наоборот: мы знаем движение подвижной СО, знаем движение тела относительно подвижной СО, тогда мы можем найти движение тела относительно неподвижной СО, т.е. относительно земли.

Рассмотрим движение тела относительно двух разных СО, движущихся относительно друг друга: одна СО неподвижна, другая движется равномерно и прямолинейно.

Река, два берега, известно течение реки, плот плывёт вдоль течения, к плоту причалена лодка. На берегу и на плоту есть наблюдатели, оба наблюдают за лодкой. Лодка отчаливает от плота и движется к противоположному берегу равномерно и прямолинейно:

На интерактиве даны плот, который привязан к пирсу(зелёный прямоугольник), а к плоту причалена лодка. После нажатия на Move плот отвязывается от пирса, а лодка отчаливает от плота. Движение на интерактиве можно рассмотреть относительно трёх различных СО.

Нарисуем векторы перемещений лодки в двух СО: относительно берега и относительно плота:

1. Поскольку берег неподвижный, то первый вектор назовём абсолютным перемещением: S_абс.
2. Поскольку плот движется, то второй вектор назовём относительным перемещением: S_отн.
3. Река перенесла плот, а вместе с ней и лодку. Получим переносный вектор: S_пер.

Получили знакомую, по векторной сумме, тройку векторов:

S_абс = S_отн + S_пер

Поскольку в механике очень важно описывать движение, то нужно знать векторы скорости. Их легко получить, потому что эти перемещения совершены за одинаковый промежуток времени t, тогда разделим каждое перемещение на эти промежутки, получим три вектора скорости:

S_абс/t = S_отн/t + S_пер/t

или:

u_абс = u_отн + u_пер

Это закон сложения скоростей. Он звучит так:

Скорость тела относительно неподвижной СО равна векторной сумме скорости тела относительно движущейся СО и скорости движущейся СО относительно неподвижной.

Закон сложения скоростей написан в векторной форме, это значит, что его можно использовать для самых разных случаев. Рассмотрим два простых, которые мы часто видим в жизни.

Скорый поезд обгоняет электропоезд. Мы едем в электропоезде. Скорость электропоезда 60 км/ч, а – скорого 90 км/ч. Найдите скорость скорого поезда относительно электропоезда.

Дано: u_э = 60 км/ч, u_с = 90 км/ч. Найти: u_отн

!!! Нужно уметь определять как связаны скорости u_э и u_с к величинам закона сложения скоростей !!!

Поведём аналогию движения лодки и плота с движениями поездов: мы едем в электропоезде, а относительно нас едет скорый, тогда электропоезд сравниваем с плотом, а скорый поезд с лодкой.

Движение электропоезда обозначим как вектор переносной скорости: u_э = u_пер (это скорость той СО, в которой находимся мы). А движение скорого – как вектор абсолютной скорости: u_с = u_абс (её увидел бы наблюдатель на дороге).

u_отн – это скорость, которую видит пассажир электропоезда, когда смотрит на скорый. Или скорость, которую видит пассажир скорого поезда, когда смотрит на электропоезд.

u_пер=u_э – это скорость, которую видит наблюдатель на земле, когда смотрит на электропоезд. Или скорость, которую видит пассажир электропоезда, когда смотрит на стоящего наблюдателя.

u_абс=u_с – это скорость, которую видит наблюдатель на земле, когда смотрит на скорый поезд. Или скорость, которую видит пассажир скорого поезда, когда смотрит на стоящего наблюдателя.

Подставим в закон сложения скоростей наши векторы:

u_с = u_отн + u_э

Мы ищем скорость скорого поезда относительно электропоезда – это u_отн

Тогда: u_отн = u_с – u_э

Т.к. это векторы, то полученная формула справедлива как для попутного, так и для встречного движения. Докажем это:

Рассмотрим два случая: попутное и встречное движение.

а) Попутное движение. Уберём векторы, для этого нарисуем ось и спроецируем векторы:

u_{отн x} = u_{с x} – u_{э x}

Т.к. направления скоростей совпадают с направлением ОХ, то их проекции равны модулям скорости:

u_{отн x} = u_с – u_э = 90 км/ч – 60 км/ч = 30 км/ч

Итак, пассажир электропоезда видит две вещи: 1 скорость скорого поезда 30 км/ч, 2 эта скорость вдоль оси x.

Последняя формула ничего не говорит о том, где находится скорый – за или перед электропоездом, потому что она говорит только об относительной скорости, которая везде одинакова!

Формула с проекциями не зависит от того куда едет электропоезд и/или скорый поезд, потому что она совпадает с векторной формулой. Значит её можно учесть в случае б)

б) Встречное движение. Электропоезд движется туда же, а скорый – навстречу ему. Скорости те же. Спроецируем их на ось х:

u_{отн x} = u_{с x} – u_{э x}

u_{отн x} = –u_с – u_э = 90 км/ч – 60 км/ч = 30 км/ч

Минус говорит о движении против оси x.

Мы доказали, что векторная формула годиться для двух случаев, т.е. она не зависит от направления.

За 4 ч моторная лодка проходит против течения расстояние 48 км. За какое время она пройдёт обратный путь, если скорость течения равна 3 км/ч?

t_пр, ℓ, u_т

t_по-?

u_абс = u_отн + u_пер

u_отн – скорость лодки относительно воды, u_пер – скорость реки.

На рисунке длины векторов скорости получаются путём сложения вектора скорости реки и векторов скоростей лодок относительно воды.

Если направление течения совпадает с направлением лодки, то обе скорости складываются, и полученная сумма связывается с ℓ и t_по:

u_л + u_т = ℓ / t_по (1)

Если лодка движется против течения, то u_отн и u_пер направлены противоположно . Например, если лодка проходит на 10 м влево относительно воды, но вода течёт вправо на 2 м, получается, что лодка прошла 10-2 м, т.е. скорости вычитаются, и полученная разность связывается с ℓ и t_пр:

u_л — u_т = ℓ / t_пр (2)

Законов сложения расстояний или времён нет, но есть закон сложения скоростей, поэтому можно связать скорости с теми величинами, которые есть. Вычтем одно равенство из другого – (1) — (2):

(u_л + u_т) — (u_л — u_т) = ℓ / t_по — ℓ / t_пр

u_л + u_т — u_л + u_т = ℓ / t_по — ℓ / t_пр

2u_т = ℓ / t_по — ℓ / t_пр

мы связали друг с другом все величины, которые у нас есть

2u_т + ℓ / t_пр = ℓ / t_по

(2u_т·t_пр + ℓ) / t_пр = ℓ / t_по

t_по = t_пр·ℓ/(2u_т·t_пр + ℓ)

по формуле видно, что дробь безразмерная величина

Моторная лодка за 1,5 ч доставляет почту из города в посёлок, расположенный ниже по течению реки. Сколько времени займёт обратный путь, если скорость движения лодки относительно воды в 4 раза больше скорости течения реки?

t_по, n,

u_л=nu_т

u_абс = u_отн + u_пер

Добавим на рисунок ℓ и u_т, их нет в условии, но в природе они есть, и они связаны с законом сложения скоростей.

Рассмотрим две абсолютные скорости, которые видны с берега – по течению и против. По течению – это сумма скорости лодки относительно воды (u_отн) и скорости течения (u_пер она же u_т)

Свяжем эти абсолютные скорости с теми величинами, которые есть в задаче – t_по:

По течению: u_л + u_т = ℓ/t_по

Против течения: u_л — u_т = ℓ/t_пр

Свяжем скорости лодки и течения:

nu_т + u_т = ℓ/t_по

nu_т — u_т = ℓ/t_пр

вынесем за скобки u_т:

u_т(n+1) = ℓ/t_по(1)

u_т(n-1) = ℓ/t_пр(2)

(1)/(2):

[u_т(n+1)/u_т(n-1)] = (ℓ/t_по)·(t_пр/ℓ)

t_пр = t_по · (n+1)/(n-1) = 1,5ч·5/3 = 0,5·5 = 2,5ч

Для дроби из предыдущей задачи:

t_пр = t_по·(n+1)/(n-1)

изучите случаи когда:

а) лодка быстрая,

б) лодка медленная,

в) скорость лодки равна скорости течения.

Решение:

а) Лодка быстрая – это значит, что скорость лодки во много раз больше(>>) скорости течения:

u_л >> u_т, значит n >> 1

Говорят, что n такая огромная, что её единица особо не увеличивает и особо не уменьшает. Следовательно, единицей можно пренебречь, поэтому дробь стремится к единице, тогда:

t_пр ≈ t_по

Такая лодка будет плыть одинаковое расстояние против и по течению за почти одинаковое время.

б) Лодка медленная – это значит, что скорость лодки едва больше скорости течения, а n едва больше 1:

n ≈ 1, n > 1

перепишем дробь для n:

t_пр = t_по·2 / малое число

Поскольку в знаменателе малое число, то t_пр – большое число, значит:

t_пр >> t_по

в) если скорости лодки и течения равны, это значит, что n = 1 и знаменатель равен нулю. В таких случаях дробь равна бесконечности, тогда время возврата t_пр увеличивается до бесконечности, и лодка будет стоять на месте, потому что течение будет её возвращать на столько, на сколько она проплыла.

Стоящий на эскалаторе человек поднимается за 2 мин, а бегущий по эскалатору — за 40 с. За какое время этот человек поднимется по неподвижному эскалатору?

t_э, t_чэ,

t_ч-?

u_абс = u_отн + u_пер

Добавим на рисунок величину ℓ, её нет в задаче, но в природе она есть, и она связана с законом сложения скоростей.

u_э = ℓ / t_э (скорость эскалатора или скорость стоящего человека, её видит наблюдатель за пультом эскалатора, когда смотрит на ступеньки или на неподвижного человека, ещё это u_пер)

u_ч = ℓ / t_ч (скорость человека по неподвижному эскалатору или скорость, которую видит стоящий на эскалаторе человек, когда смотрит на бегущего по эскалатору, ещё это u_отн)

u_л + u_э = ℓ / t_чэ (скорость, которую видит наблюдатель за пультом эскалатора, когда смотрит на бегущего по эскалатору, ещё это u_абс)

(Для простоты, величины в скобках: u_абс, u_отн и u_пер указаны без векторов, на самом деле, каждая величина может быть знаковой и беззнаковой, всё зависит от того где бежит человек: относительно стоящего за ним, или перед ним, поэтому в строгом смысле, величины эти – векторы)

В третье уравнение подставим правые части первого и второго

ℓ / t_ч + ℓ / t_э = ℓ / t_чэ

· 1 / ℓ

1 / t_ч + 1 / t_э = 1 / t_чэ

1 / t_ч = 1 / t_чэ — 1 / t_э

1 / t_ч = (t_э — t_чэ) / t_э·t_чэ

t_ч = t_чэ·t_э / (t_э — t_чэ)

Эскалатор метро спускает идущего по нему вниз человека за 1 мин. Если человек будет идти вдвое быстрее, то он спустится за 45 с. Сколько времени спускается человек, стоящий на эскалаторе?

t₁, t₂, n,

u₂=nu₁

t₀-?

u_абс = u_отн + u_пер

Добавим на рисунок величину ℓ и u_э, их нет в условии, но в природе они есть, и они связаны с законом сложения скоростей.

t₀ – время спуска человека, скорость которого = 0

Свяжем величины, которые даны в условии задачи с величинами, которые есть на рисунке:

u₁ + u_э = ℓ/t₁ (скорость, которую видит наблюдатель за пультом эскалатора, когда смотрит на идущего по эскалатору)

u₂ — u_э = ℓ/t₂ (скорость, которую видит наблюдатель за пультом эскалатора, когда смотрит на вдвое быстрее идущего по эскалатору)

u_э = ℓ/t₀ (скорость эскалатора или скорость стоящего человека, её видит наблюдатель за пультом эскалатора, когда смотрит на ступеньки или на неподвижного человека)

Перепишем первые два уравнения с учётом третьего и заменим u₂ на nu₁:

u₁ + ℓ/t₀ = ℓ/t₁ — (1)

nu₁ + ℓ/t₀ = ℓ/t₂ — (2)

умножим (1) на n:

nu₁ + nℓ/t₀ = nℓ/t₁

вычтем (2) из последнего:

nℓ/t₀ — ℓ/t₀ = nℓ/t₁ — ℓ/t₂

разделим каждое слагаемое на ℓ:

n/t₀ — 1/t₀ = n/t₁ — 1/t₂

(n — 1)/t₀ = (nt₂ — t₁)/t₁t₂

t₀ = (n — 1)t₁t₂ / (nt₂ — t₁)

Анализ: при n = 1, получим t₀ = 0? Т.е. стоящий на эскалаторе человек спуститься мгновенно?

Нет, при n = 1, окажется, что t₂ = t₁, а это значит, что получим дробь 0/0, но это мат.анализ 1 курс.

Колонна войск во время похода движется со скоростью 5 км/ч, растянувшись по дороге на расстояние 400 м. Командир, находящийся в хвосте колонны, посылает велосипедиста с поручением к головному отряду. Велосипедист отправляется и едет со скоростью 25 км/ч и, на ходу выполнив поручение, сразу же возвращается обратно с той же скоростью. Через какое время после получения поручения он вернулся обратно?

u_к, ℓ, u_в

t — ?

СО – земля:

Пока велосипедист едет, колонна продолжает движение, значит для передачи поручения он должен проехать расстояние больше чем ℓ, обратно наоборот.

СО – колона:

Относительно колонны, велосипедист туда и обратно проедет одинаковое расстояние l,(это будет использоваться в следующей задаче, поэтому важно понять) но если вспомнить поезда, идущие попутно и встречно (мы тогда сидели в электропоезде), то легко найти скорость велосипедиста относительно колонны для обоих случаев:

u_к — u_в – скорость велосипедиста относительно колонны при движении вместе с колонной,

u_к + u_в – скорость велосипедиста относительно колонны при движении против колонны.

Тогда, чтобы найти общее время, достаточно сложить время движения с одной скоростью, со временем движения с другой скоростью:

t=ℓ/(u_в-u_к) + ℓ/(u_в+u_к)=

(0,4 м·60 мин/20 км) + (0,4 м·60 мин/30 км) = 0,4·3 мин + 0,4·2 мин = 1,2 мин

Скорость катера относительно воды 7 м/с, скорость течения реки 3 м/с. Когда катер двигался против течения, с него сбросили в воду мяч. Затем катер прошёл против течения 4,2 км, повернул обратно и догнал мяч. Сколько времени двигался катер от момента сбрасывания мяча до встречи с ним?

u_к, u_т, S_пр

t — ?

СО – земля:

Предположим, что вода неподвижна, тогда если катер движется с u_к, то нам не подойдёт S_пр, т.к. это расстояние пройдено против течения. Значит изучаем случай в СО – земля.

Свяжем величину, которая есть в условии задачи с величинами, которые участвуют в законе сложения скоростей, найдём t_пр:

t_пр = S_пр / (u_к-u_т)

СО – вода:

В СО связанной с водой или мячом, катер будет отплывать от мяча и приплывать к нему с одинаковой скоростью – u_к, т.е. мяч никуда не переместился, значит:

t_пр = t_по

t = t_пр + t_по = 2t_по

t_пр = 2S_пр / (u_к-u_т) = 8400м / 7 м/с — 3 м/с = 35 мин

Вывод. Можно менять СО решая одну и ту же задачу, в зависимости от того, какую ситуацию мы рассматриваем.

С угла A квадратного плота спрыгнул в воду и поплыл вокруг плота пес. Нарисуйте траекторию движения пса относительно берега, если он плывёт вдоль сторон плота, а его скорость относительно воды составляет 4/3 скорости течения реки.

u_с = 4/3u_п

Если пёс, после прыжка, проплыл сторону плота, то сколько проплыл плот?

Если пёс и плот плывут одновременно, то у них время t одинаковое. Вычислим, на сколько переместился плот, если пёс проплыл его сторону перпендикулярно реке:

t = S_c/u_c

t = S_п/u_п

S_c/u_c = S_п/u_п

S_c·u_п = S_п·u_с

S_п = S_с·u_п/u_с = 4 м·3 м/с / 4 м/с = 3 м.

После того как пёс проплыл 4 м от т. А, плот проплыл 3 м:

Далее, пёс плыл вдоль реки:

Затем снова перпендикулярно:

И наконец против течения:

Траектория:

На лодке переплывают реку, отправляясь из пункта А (см. рисунок). Скорость лодки в стоячей воде u = 5 м/с, скорость течения реки u = 3 м/с, ширина реки S = 200 м. В какой точке пристанет лодка к противоположному берегу, если держать курс перпендикулярно берегам? Какой курс следует держать, чтобы попасть в точку В? Для обоих случаев определите время переправы.

u, u, S

ℓ, a, t₁, t₂ — ?

1-й вопрос – лодка держит курс ⊥ берегу.

Держать курс перпендикулярно берегам – это значит направить нос лодки перпендикулярно берегу, но т.к. есть течение – лодку будет сносить по течению

1-й способ. Рисуем вектор скорости лодки, нос которой направлен ⊥ берегам, затем перемещение лодки (АС) и снос относительно т. B (ℓ):

ℓ = tu

где t – время, в течение которого лодку сносило вдоль реки на расстояние ℓ, а также это время, в течение которого лодка плыла ширину реки S со скоростью u, тогда:

t = S/u

ℓ = S·u/u

t = 40 c, ℓ = 120 м

2-й способ, через закон сложения скоростей.

Если u_отн – u и u_пер – u, то u_абс – u + u:

Треугольники перемещений(ABC) и скоростей подобны, значит:

u/u = ℓ/S

ℓ = S·u/u

Обратим внимание на то, что лодка одновременно участвует в двух движениях: вдоль вектора AB и вдоль вектора AC.

2-й вопрос. Лодка приплывает к т. В.

Чтобы попасть в т.В, нужно выяснить куда нужно направить вектор u, т.е. нос лодки. Для этого нужно учесть величину сноса течения, по которому нужно ориентироваться при повороте носа лодки. В этом случае, скорость лодки к т.B относительно берега – это u_абс.

u_абс = u_отн + u_пер или u_абс = u + u

Нам даны вектор u и модуль u, остаётся их нарисовать так, чтобы их сумма получила вектор u_абс

Найдём вектор u:

u = u_абс – u, но сложением удобно, поэтому: u = u_абс + (–u)

sin a = u/u

Под этим углом, нужно держать курс, чтобы попасть в т.B.

Теперь найдём время. Скорость, с которой лодка приближается к берегу – u_абс = √u² – u²

t = S/u_абс = S/√u² – u²

sin a = 0,6 => a ≈ 37°

t = 50c

Анализ: время переправы во 2-м случае больше, потому гипотенуза длиннее катета, ещё, скорость приближения к т.B (u_абс) представляет лишь часть от скорости лодки u, потому другая часть представляет собой течение.

Капли дождя из-за сопротивления воздуха падают с постоянной скоростью u, перпендикулярной поверхности земли. Как необходимо расположить цилиндрическое ведро, находящееся на движущейся со скоростью u платформе, чтобы капли не попадали на его стенки?

u, u

a — ?

Нарисуем движение капли для наблюдателя на тележке:

Капли не будут попадать на стенки ведра, когда они летят || стенкам ведра. А наблюдатель, сидя на тележке, видит их под углом a

Сопоставим наши скорости со скоростями закона сложения:

Если капли падают относительно земли, то u – это абсолютная скорость (u_абс); если u – скорость движущейся СО, то это переносная скорость (u_пер), тогда капли для сидящего на тележке падают с относительной скоростью(u_отн).

Перепишем закон сложения скоростей:

u = u_отн + u

Угол a будем находить зная u_отн:

u_отн = u — u

но сложением удобно, поэтому: u_отн = u + (–u)

Нарисуем треугольник скоростей и угол a:

Под этим углом капли будут падать на дно ведра минуя стенки.

tg a = u/u

a = arctgu/u

Анализ: чем быстрее движется тележка, тем больше тангенс и тем больше угол.

У медицинской компании есть N пунктов приёма биоматериалов на анализ. Все пункты расположены вдоль автомагистрали и имеют номера, соответствующие расстоянию от нулевой отметки до конкретного пункта. Известно количество пробирок, которое ежедневно принимают в каждом из пунктов. Пробирки перевозят в специальных транспортировочных контейнерах вместимостью не более 36 штук. Каждый транспортировочный контейнер упаковывается в пункте приёма и вскрывается только в лаборатории.

Стоимость перевозки биоматериалов равна произведению расстояния от пункта до лаборатории на количество контейнеров с пробирками. Общая стоимость перевозки за день равна сумме стоимостей перевозок из каждого пункта в лабораторию. Лабораторию расположили в одном из пунктов приёма биоматериалов таким образом, что общая стоимость доставки биоматериалов из всех пунктов минимальна.

Определите минимальную общую стоимость доставки биоматериалов из всех пунктов приёма в лабораторию.

Входные данные

Дано два входных файла ( файл A и файл B), каждый из которых в первой строке содержит число N (1 ≤ N ≤ 10 000 000) – количество пунктов приёма биоматериалов. В каждой из следующих N строк находится два числа: номер пункта и количество пробирок в этом пункте ( все числа натуральные, количество пробирок в каждом пункте не превышает 1000). Пункты перечислены в порядке их расположения вдоль дороги, начиная от нулевой отметки.

В ответе укажите два числа: сначала значение искомой величины для файла А, затем – для файла B.

Типовой пример организации данных во входном файле

6
1 100
2 200
5 4
7 3
8 2
10 190

При таких исходных данных и вместимости транспортировочного контейнера, составляющей 96 пробирок, компании выгодно открыть лабораторию в пункте 2. В этом случае сумма транспортных затрат составит: 1·2 + 3·1 + 5·1 + 6·1 + 8·2.

Решение:

Что просят?

Найти такой пункт куда дешевле доставлять контейнеры с пробирками из других пунктов. Для этого нужно посчитать стоимость доставки для каждого пункта.

Как считать стоимость?

Пусть у нас только 4 пункта:

Посчитаем стоимость доставки по формуле |расстояние| * боксы (для каждого пункта считаем расстояние к нему, умноженное на кол-во боксов каждого пункта):

Последние числа – это стоимость доставки боксов в текущий пункт. Например, стоимость доставки в первый пункт равна 32, во второй 24 и т.д. Результаты получены квадратичным(неэффективным) алгоритмом:

   cst[] = [0 0 0 0 0 0] ; массив стоимостей
   dst[] = [1 2 5 7 8 10] ; расположения пунктов
   box[] = [2 3 1 1 1 2] ; боксы (контейнеры)
   Для i от 1 до N ; dst[i] - предполагаемый пункт
   ; dst[j] – отсюда повезём боксы(box[j]) в i-й пункт
      Для j от 1 до N 
         cst[i] = cst[i] + |dst[i]-dst[j]| × box[j]

Эффективный алгоритм

Получим числа 32, 24, 24, 48 эффективным(не квадратичным) способом. Для начала вычислим первое число (32):

   cst[] = [0 0 0 0] ; массив стоимостей
   Для i от 1 до N ;
      cst[1] = |dst[i]-dst[1]| × box[i]

   ; cst[] = [38 0 0 0] получили первое число

32 – это стоимость доставки в 1-й пункт из всех остальных пунктов. Сюда входят стоимости всех боксов справа от первого пункта и не входят боксы собственно 1-го пункта(1-й пункт не доставляет боксы сам себе – |1-1|×3=0).

Чтобы вычислить стоимости доставок в следующие пункты, воспользуемся данными о доставках, хранящихся в предыдущих пунктах. Когда мы будем получать стоимости доставок в следующие пункты, вычислять заново все боксы не нужно. Нужно лишь на каждом шаге подкорректировать данные предыдущих пунктов. Например, рассмотрим вычисление стоимости для 2-го пункта:

У 2-го пункта, предыдущий пункт – 1, его стоимость 32. Это число, для 2-го пункта, содержит недостающие и лишние данные. Недостающие данные – это та стоимость, которую мы не учли для 1-го пункта: для 1-го пункта не учтены 3 бокса (свои боксы себе возить ненужно), поэтому их нужно добавить для 2-го пункта. Лишние данные – это та стоимость, которая вошла при перевозки боксов всех пунктов, но на расстояние между 2-м и 1-м пунктом. Значит нужно вычесть длину смещения между нынешним пунктом(2) и предыдущим(1) умноженное на все боксы (другими словами, после смещения вправо предыдущая стоимость содержит лишнее значение равное длине смещения умноженное на все боксы).

Вычитание лишних и добавление недостающих данных

Вычитание лишних данных для 2-го пункта:

32 – (3-1)*2 + (3-1)*4 + (3-1)*1

но лучше так:

32 – (3-1)*(2 + 4 + 1)

Такое упрощение позволит получить оптимальный способ решения задачи – вторая скобка содержит сумму всех боксов(без 1-го пункта), и поскольку кол-во боксов известно заранее, их сумму можно вычислить один раз, для одного пункта, чтобы затем использовать для остальных пунктов. Например, для 3-го пункта вычитание будет таким:

…– (6-3)*(4 + 1)

т.е. для 3-го пункта двойку убрали.

Теперь рассмотрим добавление недостающих данных для 2-го пункта:

…+ (3-1)*3

для 3-го:

…+ (6-3)*(3+2)

Общая картина вычислений начиная со 2-го пункта (1-й пункт вычислен заранее неэффективным способом):

32 – (3-1)*(2 + 4 + 1) + (3-1)*3 = 24
24 – (6-3)*(4 + 1) + (6-3)*(3 + 2) = 24
24 – (9-6)*(1) + (9-6)*(3 + 2 + 4) = 48

boxes = 10 ; все боксы – посчитанные на 1-м проходе
left = box[1] ;left=3 боксы слева
right = boxes - left ; right=7 боксы справа
Для i от 2 до N ; начинаем со второго пункта
   cst[i] = cst[i-1] - (dst[i] - dst[i-1]) * right
                     + (dst[i] - dst[i-1]) * left

; dst[i]-dst[i-1] – расстояние на которое мы переместились слева направо
; cst[i] – стоимость доставки в текущий пункт
; cst[i-1] – ранее вычисленная стоимость доставки, которую нужно подкорректировать

; настроим боксы от которых ушли и к которым пришли
   right = right - box[i]   
   left = left + box[i]

; получение числа 24 из 32 для 2-го пункта:
; 24 = 32 – (3 - 1) * 7 + (3 - 1) * 3
Настраиваем указатели для 3-го пункта
; right = 7-2  к этим пришли, зн. их вычтем
; left = 3+2  от этих ушли, зн. их добавим

; получение числа 24 из 24 для 3-го пункта:
; 24 = 24 – (6 - 3) * 5 + (6 - 3) * 5
Настраиваем указатели для 4-го пункта
; right = 5-4  к этим пришли, зн. их вычтем
; left = 5+4  от этих ушли, зн. их добавим

; получение числа 48 из 24 для 4-го пункта:
; 48 = 24 – (9 - 6) * 1 + (9 - 6) * 9

Полный код на Python

f=open('27_B.txt')
n=int(f.readline())

dst=[0]*n #расположения пунктов
box=[0]*n #контейнеры(боксы)
cst=[0]*n #стоимости
boxes=0 #все контейнеры(боксы)

k=36

for i in range(n):
    x,y=map(int,f.readline().split())

    dst[i]=x
    box[i]=y//k + 1*(y%k!=0)

    cst[0] += (dst[i]-dst[0])*box[i]
    boxes += box[i]#суммируем все боксы

left = box[0]
right = boxes - left
for i in range(1,n):
    cst[i] = cst[i - 1] - (dst[i] - dst[i - 1]) * right \
                        + (dst[i] - dst[i - 1]) * left

    right -= box[i]
    left += box[i]

print(min(cst))

Дана последовательность из N натуральных чисел. Рассматриваются все её непрерывные подпоследовательности, такие что сумма элементов каждой из них кратна k = 43. Найдите среди них подпоследовательность с максимальной суммой, определите её длину. Если таких подпоследовательностей найдено несколько, в ответе укажите количество элементов самой короткой из них.

Входные данные

Даны два входных файла (файл A и файл B), каждый из которых содержит в первой строке количество чисел N (1 ≤ N ≤ 10 000 000). Каждая из следующих N строк содержит одно натуральное число, не превышающее 10 000.

Пример организации исходных данных во входном файле:

7
1
3
4
93
8
5
95

В ответе укажите два числа: сначала значение искомой длины для файла А, затем – для файла B.

Предупреждение: для обработки файла B не следует использовать переборный алгоритм, вычисляющий сумму для всех возможных вариантов, поскольку написанная по такому алгоритму программа будет выполняться слишком долго

Эффективный поиск подпоследовательности

Рассмотрим суть эффективного поиска числовой подпоследовательности, сумма которой делится на нужное число без остатка. Для простоты возьмём такую последовательность, у которой две подпоследовательности делятся, например, на 10: [2 1 5 7 8 4 12 8]

Просуммируем каждое число последовательности и разместим полученные суммы под числами последовательности:

Чтобы найти первую подпоследовательность (5 7 8), посмотрим на сумму, которая стоит под числом 8. Это число 23. Его можно превратить в 20, если вычесть 3, а число 3 стоит как вторая сумма. Значит, для поиска подпоследовательности, сумма которой делится на 10 без остатка, нужно из одной суммы вычесть другую: 2+1+5+7+8 – 2+1 = 5+7+8.

Подпоследовательность 2 1 называют «хвостом» подпоследовательности 2 1 5 7 8, который нужно вычесть, чтобы получить нужный результат:

Как теперь найти, что из общей суммы: 2+1+5+7+8 нужно вычесть именно 2+1, чтобы гарантированно получить результат, который делится на 10 без остатка?

Есть такое правило:

…которое говорит, что если два числа при делении на k дают один и тот же остаток, то их разность делится на k без остатка. У нас a – это сумма 2+1+5+7+8, b – это сумма 2+1, а k это 10

Теперь исследуем остатки, которые получатся при делении каждой суммы на 10:

Есть одинаковые остатки! Это поможет найти и вычесть хвост у последовательности, и задача решена. Рассмотрим как следить за остатками.

Массив остатков

Наша задача сохранить все суммы, и пометить какой у них остаток при делении на k. Для этого создадим массив tailSum размером k. Индекс элемента этого массива – это остаток при делении очередной суммы на k. Эту сумму нам нужно занести в массив по её остатку. Тем самым мы пометим под каким остатком хранится та или иная сумма.

Так вот, один и тот же остаток должен встретится ещё раз в процессе суммирования. А это значит, что в массиве tailSum – по индексу остатка – уже сохранена ранее сумма, и если её вычесть из общей суммы(totalSum), – получится нужная сумма(curSum).

Рассмотрим всё это по шагам:

 m = [2 1 5 7 8 4 12 8]
 k = 10
 totalSum = 0
 tailSum - [0 0 0 0 0 0 0 0 0 0]

  1 шаг
 totalSum = 2
 ;если tailSum[2 % k] = 0
 ;то в tailSum[2 % k] = 2
 tailSum - [0 0 2 0 0 0 0 0 0 0]
  
  2 шаг
 totalSum = 3
 ;если tailSum[3 % k] = 0
 ;то в tailSum[3 % k] = 3
 tailSum - [0 0 2 3 0 0 0 0 0 0]
  
  3 шаг
 totalSum = 8
 ;если tailSum[8 % k] = 0
 ;то в tailSum[8 % k] = 8
 tailSum - [0 0 2 3 0 0 0 0 8 0]
  
  4 шаг
 totalSum = 15
 ;если tailSum[15 % k] = 0
 ;то в tailSum[15 % k] = 15
 tailSum - [0 0 2 3 0 15 0 0 8 0]
  
  5 шаг
 totalSum = 23
 ;если tailSum[23 % k] != 0
 ;то curSum = totalSum - tailSum[23 % k] 23 – 3
 curSum = 20 ;нужная сумма

Программа на Python

   m = [2,1,5,7,8,4,12,8] #данная последовательность
   n = len(m)
   k = 10
   totalSum = 0
   tailSum = [0]*k  #[0 0 0 0 0 0 0 0 0 0]
   for i in range(n):
      totalSum += m[i]
      r = totalSum % k
      if tailSum[r] == 0: #был ли такой остаток или нет?
      # такого остатка ещё не было =>
      сохраняем сумму(потенциальный хвост)
      и помечаем под каким она остатком
         tailSum[r] = totalSum
      else: #такой остаток уже есть => 
      вычитаем предыдущую сумму(хвост) из текущей
         curSum = totalSum - tailSum[r]

Длина подпоследовательности

Длина подпоследовательности – это разность между двумя значениями циклической переменной i. Первое значение (начало подпоследовательности) сохраним в массив tailLen. Второе значение (конец подпоследовательности). Первое значение соответствует моменту, когда мы сохраняли первую сумму для отсечения хвоста, второе – когда нашли в tailSum не нулевое значение. Следовательно, tailLen аналогичен tailSum:

   …
   tailLen = [0]*k
   for i in range(n):
      …
      if tailSum[r] == None:
         …
         #i – первое значение длины - сохраним в tailLen
		 tailLen[r] = i
      else:
          …
		 #i – второе значение длины - из него вычтем первое
         curLen = i - tailLen[r]

Максимальная и самая короткая сумма

Максимальная сумма находится обычным делом. Кроме этого, текущая сумма может быть равной максимальной(встретились две одинаковые нужные суммы), тогда нужно убедиться, что кол-во элементов текущей суммы(currLen) меньше кол-ва элементов максимальной суммы(maxSum). Раз так – модифицируем переменные maxSum и minLen текущими значениями суммы и длины:

   …
   maxSum = minLen = 0
   for i in range(n):
   …
   else:
      …
      if curSum > maxSum or \
         (curSum == maxSum and curLen < minLen):
            maxSum = curSum
            minLen = curLen

Полный код на Python (подпоследовательность не сначала)

   m = [2,1,5,7,8,4,12,8]
   n = len(m)
   tailSum=[0]*k
   tailLen=[0]*k
   minLen=float('inf')
   totalSum=curSum=maxSum=curLen=0
   for i in range(n):
      totalSum += m[i]
      r = totalSum % k
       if tailSum[r] == 0:
          tailSum[r] = totalSum 
          tailLen[r] = i
       else: 
          curSum = totalSum - tailSum[r]
          curLen = i - tailLen[r]
          if curSum > maxSum or \
            curSum == maxSum and curLen < minLen:
             maxSum = curSum
             minLen = curLen
   print(minLen,)

Если нужная подпоследовательность вначале массива, то остаток r равен нулю, а totalSum – есть найденная сумма. При увеличении totalSum – сумма будет увеличиваться, значит проверять на максимум не нужно. Остаётся проверить длину на минимум:

Полный код на Python (подпоследовательность сначала)

   m=[5,7,8,8,4,12]
   n = len(m)
   tailSum=[0]*k
   tailLen=[0]*k
   minLen=float('inf')
   totalSum=curSum=maxSum=curLen=0
   for i in range(n):
      totalSum += m[i]
      r = totalSum % k
       if r == 0 and i < minLen:
          maxSum = totalSum 
          minLen = i+1
   print(minLen,)

Полный код на Python

   f=open('27_B.txt')
   n=int(f.readline())
   k=43
   totalSum=curSum=maxSum=curLen=0
   tailSum=[0]*k
   tailLen=[0]*k
   minLen=float('inf')
   for i in range(n):
      totalSum+=int(f.readline())
      r=totalSum%k
      if r!=0:
         if tailSum[r] == 0:
            tailSum[r] = totalSum
            tailLen[r] = i
         else:
            curSum = totalSum - tailSum[r]
            curLen = i - tailLen[r]
            if curSum > maxSum or \
              curSum == maxSum and curLen < minLen:
               maxSum = curSum
               minLen = curLen
      elif i < minLen:
         maxSum = totalSum
         minLen = i+1
print(minLen)

Имеется набор данных, состоящий из пар положительных целых чисел. Необходимо выбрать из каждой пары ровно одно число так, чтобы сумма всех выбранных чисел не делилась на 3 и при этом была максимально возможной. Гарантируется, что искомую сумму получить можно.

Программа должна напечатать одно число – максимально возможную сумму, соответствующую условиям задачи.

Входные данные

Даны два входных файла (файл A и файл B), каждый из которых содержит в первой строке количество пар N (1 ≤ N ≤ 10 000 000). Каждая из следующих N строк содержит два натуральных числа, не превышающих 10 000.

Пример организации исходных данных во входном файле:

6
1 3
5 12
6 9
5 4
3 3
1 1

Для указанных входных данных значением искомой суммы должно быть число 32.

В ответе укажите два числа: сначала значение искомой длины для файла А, затем – для файла B.

Предупреждение: для обработки файла B не следует использовать переборный алгоритм, вычисляющий сумму для всех возможных вариантов, поскольку написанная по такому алгоритму программа будет выполняться слишком долго

Сумма максимумов

Выберем данную последовательность из шести пар и просуммируем максимальное число каждой пары:

   l = [1,5,6,5,3,1] # первое число пары
   r = [3,12,9,4,3,1] # второе число пары
   n = len(l) # а можно и len(r)
   s = 0
   for i in range(n):
      a=l[i]; b=r[i]
      s += max(a, b)

Сумма будет 33(переменная s). Если бы сумма не делилась на 3, то она бы являлась ответом. Но она делится, значит, одно максимальное число(неважно какое), которое попало в сумму, нужно поменять на минимальное из той же пары – да так поменять, что это минимальное в паре число, должно быть самым минимальным среди всех минимальных(это условие максимально возможной суммы).

Поиск нужного минимума

В нашем примере, вместо максимального числа 5, нужно использовать 4. Как его найти эффективно?

В процессе суммирования находим минимальную разницу между парами, которая не делится на 3:

   ...
   min = 10001
   for i in range(n):
      ...
      d = abs(a-b)
      if(d%3 != 0) and (d < min):
         min = d

Единица в последней паре не подойдёт в качестве минимума, потому что оба числа пары равны и от того первое выражение условия даст отрицание.

Вывод на экран

Переменную min применим, если сумма делится на 3, иначе выведем сумму:

   ...
   for i in range(n):
      ...
   if s%3==0:
      print(s-min)
   else:
      print(s)

Полный код на Python

   f = open('27.txt')
   n = int(f.readline())
   s = 0
   min = 10001
   for i in range(n):
      a,b = map(int,f.readline().split())
      s += max(a,b)
      d = abs(a-b)
      if(d%3 != 0) and (d < min):
         min = d
# вывод на экран
   if s%3==0:
      print(s-min)
   else:
      print(s)

На вход программы поступает последовательность из n целых положительных чисел. Рассматриваются все пары элементов последовательности a_i и a_j, такие что i < j и a_i > a_j (первый элемент пары больше второго; i и j – порядковые номера чисел в последовательности входных данных). Среди пар, удовлетворяющих этому условию, необходимо найти и напечатать пару с максимальной суммой элементов, которая делится на m = 120. Если среди найденных пар максимальную сумму имеют несколько, то можно напечатать любую из них.

Описание входных и выходных данных

В первой строке входных данных задаётся количество чисел n (2 ≤ n ≤ 12 000). В каждой из последующих n строк записано одно целое положительное число, не превышающее 10 000.

В качестве результата программа должна напечатать элементы искомой пары. Если таких пар несколько, можно вывести любую из них. Гарантируется, что хотя бы одна такая пара в последовательности есть.

Пример входных данных:

6
60
140
61
100
300
59

Пример выходных данных для приведённого выше примера входных данных:

140 100

Пояснение.Из шести заданных чисел можно составить три пары, сумма элементов которых делится на m=120: 60+300, 140+100 и 61+59. Во второй и третьей из этих пар первый элемент больше второго, но во второй паре сумма больше.

Требуется написать эффективную по времени и памяти программу для решения описанной задачи.

Поиск пары

Пары будут двух типов: каждый элемент пары не кратный m, а сумма элементов кратна, и каждый элемент пары кратный m – сумма также кратна.

Рассмотрим, как искать пару, сумма которой кратна m, но каждый элемент не кратный. Есть правило:

которое говорит, что если два числа при делении на m дают остатки, сумма которых делится на m, то и сумма чисел делится на m. Например: пусть m=5, a=8 и b=12, тогда:

Теперь как найти, среди последовательности чисел, пару 8 и 12, сумма которой делится на 5.

Удобнее всего через так называемый массив остатков r размером m. На самом деле элементы этого массива – это числа последовательности, а индексы этих элементов – остатки от деления элементов на m. Пусть наши 8 и 12 расположены в такой последовательности: [ 8 14 12 ], тогда массив остатков r[m] будет таким:

Мы ищем пару по индексам: пусть под одним индексом есть ненулевой элемент массива, тогда если мы обнаруживаем, что есть ещё ненулевой элемент, индекс которого даёт сумму с первым индексом кратную 5, то сумма элементов также кратна 5.

Как найти 2-й индекс? По m и по 1-му индексу: 2-й индекс = m – 1-й индекс. В нашем случае 2-й индекс это 3, а 1-й – это 2. Всё потому что, когда мы проверяем число 8(индекс 3) - его пара под индексом 2 хранит нулевое значение и поэтому по 3-му индексу пару найти невозможно:

Но когда проверяем число 12 (индекс 2) - его пара под индексом 3 хранит не нулевое значение:

Вот тогда то, мы и находим нужную пару:

 
   m = 5
   d = [8,14,12] # последовательность
   r = [0,0,0,0,0] # массив «остатков»
   for i in range(len(d)):
      a = d[i] # a удобнее чем d[i]
      p = a % m
      if r[m-p]>0: # false при a=8, true при a=12 
         print (r[m-p], " ", a) # 8 12
      r[p] = a # заполняем массив остатков (пока они различны)

Первый больше второго

По условию, первый элемент пары должен быть больше, значит наша последовательность - [ 8 14 12 ] - не содержит нужной пары. Поменяем местами 8 и 12 и в условии учтём, что предыдущий сохранённый элемент массива остатков больше чем текущий:

 
   m = 5
   d = [12,14,8] # последовательность
   r = [0,0,0,0,0] # массив «остатков»
   for i in range(len(d)):
      a = d[i] # a удобнее чем d[i]
      p = a % m
      if r[m-p]>a: # предыдущий r[m-p] больше текущего a 
         print (r[m-p], " ", a) # 8 12
      r[p] = a # заполняем массив остатков (пока они различны)

Теперь предыдущая последовательность - в связи с тем, что она неправильная - не будет найдена.

Пара с максимальной суммой

По условию, нужная пара должна давать максимальную сумму среди всех нужных пар, т.е. пар может быть несколько, а выбрать нужно ту, которая даёт максимальную сумму. Добавим в условие выражение, которое сравнивает сумму текущей пары с парой сохранённой ранее

Кроме этого, нужно учесть, что в последовательности может быть не одно число с одним и те же остатком, тогда если оно больше предыдущего, то в массиве остатков меняем предыдущее на текущее. Если остатки разные, то массив остатков будет заполняться, так же как и раньше:

 
   m = 5
   d = [22,38,8,14,2] # Нужная 38 и 2 среди ещё одной 22 и 8
   r = [0,0,0,0,0] # массив «остатков»
   left = 0; right = 0 # элементы нужной пары
   for i in range(len(d)):
      a = d[i] # a удобнее чем d[i]
      p = a % m
      if r[m-p]>a and r[m-p]+a > left+right:
         left = r[m-p]
         right = a
      if a>r[p]: # a > предыдущего с таким же остатком
         r[p] = a # значит заменим его на a
   print (l, " ", r) # 38 2

Один тип пары мы выбрали, переходим к другому типу – каждый элемент которого кратный m.

Пара элементов кратные m

Случай с одной парой, причём пусть, первый элемент меньше второго(далее исправим): [10, 14, 15]

 
   m = 5
   d = [5,14,10] # последовательность
   r = [0,0,0,0,0] # массив «остатков»
   for i in range(len(d)):
      a = d[i] # a удобнее чем d[i]
      p = a % m
      if r[m-p]>0: # false при a=8, true при a=12 
         print (r[m-p], " ", a) # 8 12
      r[p] = a # заполняем массив остатков (пока они различны)

Первый больше второго(среди кратных m)

Поменяем местами 5 и 10, затем изменим условие:

 
   m = 5
   d = [10,14,5] # последовательность
   r = [0,0,0,0,0] # массив «остатков»
   for i in range(len(d)):
      a = d[i] # a удобнее чем d[i]
      p = a % m
      if r[0]>a: # предыдущий r[0] больше текущего a 
         print (r[0], " ", a) # 10 5
      r[p] = a # заполняем массив остатков (пока они различны)

Теперь предыдущая последовательность, в связи с тем, что она неправильная, не будет найдена.

Пара с максимальной суммой(среди кратных m)

Аналогично соответствующему пункту данной задачи добавим переменные для максимальных элементов пар и изменим условие:

 
   m = 5
   d = [10,35,5,14,15] # Нужная 35 и 15, ненужная 22 и 8
   r = [0,0,0,0,0] # массив «остатков»
   left = 0; right = 0 # элементы нужной пары
   for i in range(len(d)):
      a = d[i] # a удобнее чем d[i]
      p = a % m
      if r[0]>a and r[0]+a > left + right:
         left = r[0]
         right = a
      if a>r[p]: # a > предыдущего с таким же остатком
         r[p] = a # значит заменим его на a
   print (l, " ", r) # 35 15

Теперь учтём, что может быть два типа пар.

Полный код на Python

 
   d = [10,35,5,14,15,22,38,8,14,2]
   m = 120
   r = [0] * m # числа, которых ищут по остатку
   left=0; right=0
   n = len(d)
   for i in range(n):
      a = d[i]
      p = a % m
      if p == 0: # кратные m
         if r[0] > a and r[0] + a > left+right:
            left = r[0]
            right = a
      else:# не кратные m
         if r[m-p]>a and r[m-p]+a > left+right:
            left = r[m-p]
            right = a
      if a>r[p]: # a > предыдущего с таким же остатком
         r[p] = a
   print(l," ",r)

На вход программы поступает последовательность из N целых положительных чисел, все числа в последовательности различны. Рассматриваются все пары различных элементов последовательности, находящихся на расстоянии не меньше чем 4 (разница в индексах элементов пары должна быть 4 или более, порядок элементов в паре неважен). Необходимо определить количество таких пар, для которых произведение элементов делится на 29.

Описание входных и выходных данных

В первой строке входных данных задаётся количество чисел N (4 ≤ N ≤ 1000). В каждой из последующих N строк записано одно целое положительное число, не превышающее 10 000.

В качестве результата программа должна вывести одно число: количество пар элементов, находящихся в последовательности на расстоянии не меньше чем 4, в которых произведение элементов кратно 29.

Пример входных данных:

7
58
2
3
5
4
1
29

Пример выходных данных для приведённого выше примера входных данных:

5

Пояснение.Из 7 заданных элементов с учётом допустимых расстояний между ними можно составить 6 произведений: 58·4, 58·1, 58·29, 2·1, 2·29, 3·29. Из них на 29 делятся 5 произведений.

Требуется написать эффективную по времени и памяти программу для решения описанной задачи.

Программа считается эффективной по времени, если при увеличении количества исходных чисел N в k раз время работы программы увеличивается не более чем в k раз.

Внимание! Для простоты, вместо деления на 29 будем проверять на чётность.

Эффективный алгоритм по времени, но не по памяти

Будем умножать конкретное число x с остальными числами последовательности, которые стоят на расстоянии ≥ 4 от x. Следовательно, ближайшие к x три числа пропускаем мимо. x.

Закрасим ненужные 3 числа красным, x – зелёным, а умножаемые с x–ом числа – синим цветом.

Может быть два случая:

1. x – чётный
2. x – нечётный

Тогда суммируем либо все синие числа(случай 1), либо только те синие, которые делятся на 2 (случай 2).

В 1-м случае кол-во чётных результатов будет равно кол-ву произведений x–а с числами синего цвета:

шаг 1

одно произведение: 6 * 8, здесь x = 6, он на 5-ом месте последовательности (нумерация с 1)

шаг 2

два произведения: 2 * 8 и 2 * 3, здесь x = 2, он на 2-ом месте последовательности

шаг 4

четыре произведения: 4 * 8, 4 * 3, 4 * 4, 4 * 7, здесь x = 4, он на 8-ом месте последовательности

В 2-м случае кол-во чётных результатов будет равно только кол-ву чётных синих чисел:

шаг 3

два произведения: 1*8 и 1*4, здесь x = 1, он на 7-ом месте последовательности

Для 1-го случая считать чётные произведения будет разница положения x–а и кол-во розовых чисел:

   count = count + x – 3

Для 2-го случая понадобится переменная, которая считает чётные синие числа

   count = count + b ;где b уже знает сколько чётных синих

Остаётся считать кол-во чётных синих чисел:

   b = b + 1

Полный код на Python

   d = 4 #расстояние до ближайшего нужного числа
   a = [8,3,4,7,6,2,1,4]
   n = len(a)
   count = 0 #кол-во чётных пар всего
   b = 0 #кол-во чётных синих чисел
   for i in range(d,n): #прицеливаемся на x=6
      if a[i-d]%2 == 0:
         b += 1
      if a[i]%2 == 0: #x делится на то что нужно?
         count += i-d+1 #count=count+x-3
      else:
         count += b
   print(count)

На вход программы поступает последовательность из N целых положительных чисел, все числа в последовательности различны. Рассматриваются все пары различных элементов последовательности (элементы пары не обязаны стоять в последовательности рядом, порядок элементов в паре не важен). Необходимо определить количество пар, для которых произведение элементов делится на 26.

Описание входных и выходных данных

В первой строке входных данных задаётся количество чисел N (4 ≤ N ≤ 1000). В каждой из последующих N строк записано одно целое положительное число, не превышающее 10 000. В качестве результата программа должна напечатать одно число: количество пар, в которых произведение элементов кратно 26.

Пример входных данных:

4
2
6
13
39

Пример выходных данных для приведённого выше примера входных данных:

4

Пояснение.Из четырёх заданных чисел можно составить 6 попарных произведений: 2·6, 2·13, 2·39, 6·13, 6·39, 13·39 (результаты: 12, 26, 78, 78, 234, 507). Из них на 26 делятся 4 произведения (2·13=26; 2·39=78; 6·13=78; 6·39=234).

Требуется написать эффективную по времени и по памяти программу для решения описанной задачи.

Программа считается эффективной по времени, если при увеличении количества исходных чисел N в k раз время работы программы увеличивается не более чем в k раз.

Решение

Пример входных данных неудачный: он не содержит чисел 26, поэтому мы не можем учесть такие пары, в которых либо ОБА элемента делятся на 26, либо ТОЛЬКО ОДИН. Пусть будет такая последовательность: 26 3 8 52 78. Из неё получаем неповторяющиеся пары: 26-3, 26-8, 26-52, 26-78, 3-8, 3-52, 3-78, 8-52, 8-78, 52-78. Теперь посчитаем, сколько будет произведений пар, которые делятся на 26.

ОБА элемента делятся на 26

Если оба элемента делятся на 26, то и их произведения тоже делятся. Из неповторяющихся пар, есть три пары, у которых оба элемента делятся на 26: 26-52, 26-78, 52-78. Формула, которая вычисляет кол-ва таких пар: (n26·(n26-1))/2, где n26 – это количество чисел в последовательности, которые делятся на 26. У нас n26=3(26,52 и 78), значит (3·(3-1))/2=3

ТОЛЬКО ОДИН элемент делится на 26

Шесть пар, у которых только один элемент делится на 26: 26-3, 26-8, 3-52, 3-78, 8-52, 8-78. Формула, которая вычисляет кол-ва таких пар: n26·(n-n26), где n – это количество чисел в последовательности. У нас n=5, значит 3·(5-3)=6

26=2·13

Теперь, случай, где элементы не кратны 26, но их произведение дадут число 26. Это число можно получить по двум множителям: 2 и 13. Значит нужно посчитать кол-во пар, у которых один элемент 2, другой 13. Для этого есть формула: n2·n13, где n2 – это кол-во чисел, которые делятся на 2 и n13 – кол-во чисел, которые делятся на 13.

Полный код на Python

   f = open('2018_27.txt') #4 2 6 13 39
   n = int(f.readline())#n=4
   n26 = n2 = n13 = 0
   for i in range(n):
      x = int(f.readline())
      if x%26 == 0:
         n26 += 1
      elif x%13 == 0:
         n13 += 1
      elif x%2 == 0:
         n2 += 1      
   print((n26*(n26-1))//2+n26*(n-n26)+n2*n13)

В физической лаборатории проводится долговременный эксперимент по изучению гравитационного поля Земли. По каналу связи каждую минуту в лабораторию передаётся положительное целое число – текущее показание прибора «Сигма 2015». Количество передаваемых чисел в серии известно и не превышает 10 000. Все числа не превышают 1000. Временем, в течение которого происходит передача, можно пренебречь. Необходимо вычислить « бета-значение» серии показаний прибора – минимальное чётное произведение двух показаний, между моментами передачи которых прошло не менее 6 минут. Если получить такое произведение не удаётся, ответ считается равным –1.

Напишите программу для решения поставленной задачи, которая будет эффективна как по времени, так и по памяти (или хотя бы по одной из этих характеристик). Программа считается эффективной по времени, если время работы программы пропорционально количеству полученных показаний прибора N, т.е. при увеличении N в k раз время работы программы должно увеличиваться не более чем в k раз. Программа считается эффективной по памяти, если размер памяти, использованной в программе для хранения данных, не зависит от числа N и не превышает 1 килобайта.

Входные данные представлены следующим образом. В первой строке задаётся число N – общее количество показаний прибора. Гарантируется, что N > 6. В каждой из следующих N строк задаётся одно положительное целое число – очередное показание прибора.

Пример входных данных:

11
12
45
5
3
17
23
21
20
19
18
17

Программа должна вывести одно число – описанное в условии произведение либо –1, если получить такое произведение не удаётся.

Пример выходных данных для приведённого выше примера входных данных: 54

Решение

Пусть для простоты расстояние будет не 6, а 3, и возьмём небольшие числа: 6 1 3 5 7 9 2 4 8. После того как составим алгоритм заменим 3 на 6.

Множители на расстоянии

Сохраним 1-ые 3 элемента входных данных в массив. Затем настроимся к оставшимся числам последовательности:

   a = [6 1 3 5 7 9 2 4 8]
   m = [6 1 3] # сохраняем первые 3 
   for i in range(3,n):# i = [3..n)

Получилась заготовка для обращений чисел, расположенных на расстоянии трёх элементов. Элементы массива m выделены синим цветом, а нужные элементы массива a – зелёным.

Умножение

Схема умножения для первых трёх шагов:

Перед умножением элемента массива m, проверим его на минимум и сохраним его в minx:

   …
   minx = 1001   
   for i in range(3,n):# a[3] = 5
      if m[i%3] < minx: #[3%3]=0, [4%3]=1, [5%3]=2
         minx = m[i%3]

На третьем шаге в minx будет 1 – это значит, что не нужно беспокоиться о «пропущенном» произведении: 6*7, 6*9… – раз нужно минимальное произведение, то проверять произведения 6-ки со всеми кроме ближайших по условию не нужно.

Теперь умножаем числа расположенные на расстоянии 3-х элементов:

   …
   x = a[i] # a[i] = 5
   p = minx * x	 

Проверим произведение на минимум и чётность:

   …
      if (p%2==0 and p < minp):
         minp = p

minp – хранит минимальное чётное произведение, которое будет результатом

Следующее умножение

Теперь самое интересное. В конце цикла заменяем текущий элемент массива m, на x, т.о., за три шага создаём следующую тройку для произведения:

   …
      m[i%3] = x # при i=3, m[0] = 5	 

Т.е. когда, на втором шаге, будут умножаться 1 на 7 – в первом элементе массива m вместо 6 будет значение 5, которое через два шага будет умножаться на 2, и т.д. Так, выделены красным элементы массива m после трёх шагов цикла:

Теперь полный код, в котором заменено значение 3 на 6

Полный код на Python

 
  a=[12,45,5,3,17,23,21,20,19,18,17]
  n=len(a) # n=11
  m=[0]*6
  minp=1000001;minx=1001
  for i in range(6):
     m[i]=a[i]

  for i in range(6,n):
     if m[i%6] < minx:
        minx=m[i%6]
     x=a[i]
     p=minx*x
     if(p%2==0 and p < minp):
        minp=p
     m[i%6]=x
# если ни одного произведения не нашлось, то выведем -1
  if minp == 1000001:
     print (-1)
  else:
     print(minp) 

После единых выпускных экзаменов по информатике в район пришла информация о том, какой ученик, какой школы сколько набрал баллов. Эта информация в том же виде была разослана в школы.

Завуч школы № 50 решила наградить двух учащихся, которые лучше всех в школе сдали информатику.

Программа должна вывести на экран фамилии и имена этих учеников.

Если наибольший балл набрало больше двух человек – вывести количество таких учеников.

Если наибольший балл набрал один человек, а следующий балл набрало несколько человек — нужно вывести только фамилию и имя лучшего.

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например Borland Pascal 7.0), которая должна вывести на экран требуемую информацию. Известно, что информатику сдавало больше 5-ти учеников школы № 50.

На вход программе сначала подаётся число учеников, сдававших экзамен. В каждой из следующих N строк находится информация об учениках в формате:

<Фамилия> <Имя> <Номер школы> <Количество баллов>

где <Фамилия> — строка, состоящая не более чем из 30 символов без пробелов, <Имя> — строка, состоящая не более, чем из 20 символов без пробелов, <Номер школы> — целое число в диапазоне от 1 до 99, <Количество баллов> — целое число в диапазоне от 1 до 100. Эти данные записаны через пробел, причём ровно один между каждой парой (то есть, всего по три пробела в каждой строке).

Пример входной строки:
Иванов Иван 50 87
Пример выходных данных:
Круглов Василий Тарасова Дарья
Другой вариант выходных данных:
7
Третий вариант выходных данных:
Гусарский Илья

Решение:

Нужно, из множества всех учеников получить подмножество учеников конкретной школы(№50). Далее в этом подмножестве выбрать лучших учеников. Эффективная программа должна реализовать этот сложный отбор одним циклом:

	
	Цикл по всем ученикам
		Если ученик из 50-й школы то	
			Выбор лучших
	

Выбор лучших

Введём переменные:

max1 – максимальный бал или максимум,

max2 – второй максимум,

ball – текущий бал ученика 50-й школы.

Выбор лучших – это алгоритм с вложенным ветвлением. Для простоты рассмотрим его по частям. Их четыре:

1. Пусть есть возрастающая последовательность чисел, например, такая [1 2 3 4 5]: один максимум(5) и один второй максимум(4). Тогда алгоритм можно написать так:

	max1 = max2 =-1
	цикл для всех из 50-й школы
		если ball > max1 то
			max2 = max1
			max1 = ball
	

2. Теперь случай, где два одинаковых максимума(5): [1 5 3 4 5]. Добавим новую ветку условия:

	max1 = max2 =-1
	цикл для всех из 50-й школы
		если ball > max1 то
			max2 = max1
			max1 = ball
		иначе если ball = max1 то
			max2 = ball			
	

т.е. max1 и max2 содержат одинаковые значения.

3. Второй максимум(4) правее максимума(5): [1 5 3 4 2]. Добавим третью ветку условия:

	max1 = max2 =-1
	цикл для всех из 50-й школы
		если ball > max1 то
			max2 = max1
			max1 = ball
		иначе если ball = max1 то
			max2 = ball
		иначе если ball = max2 то
			max2 = ball
	

(во 2-м и 3-м условиях стоят одинаковые операторы – можно было бы написать одно сложное условие, однако далее операторы будут меняться).

4. Последний случай. Количество вторых максимумов(4) может быть более одного: [1 5 4 2 4]; здесь также добавляем условие, в котором подсчитывается их количество.

Наконец, количество максимумов(5) может быть более двух [1 5 2 5 5] – их также нужно подсчитывать. Добавим для них переменные и дополним алгоритм:

n1 – количество максимумов,

n2 – количество вторых максимумов.

	max1 = max2 =-1
	n1 = n2 = 0
	цикл для всех из 50-й школы
		если ball > max1 то
			max2 = max1
			max1 = ball
			n2 = n1
			n1 = 1
		иначе если ball = max1 то
			max2 = ball
			n1 = n1 + 1
		иначе если ball = max2 то
			max2 = ball
			n2 = 1
		иначе если ball = max2 то
			n2 = n2 + 1
	

Обратим внимание на строку n2=n1. Здесь в n1 сохранено количество «бывших» максимумов: оно может быть либо 1, либо больше 1. И ещё, оператор последнего условия не содержит присваивания переменной max2, дело в том, что в max2 уже было присвоено значение.

Имена

Осталось добавить имена учеников:

s – фамилия и имя ученика из 50-й школы,

s1 – фамилия и имя ученика с максимальным баллом,

s2 – фамилия и имя ученика с вторым максимальным баллом.

	max1 = max2 =-1
	n1 = n2 = 0
	s1 = s2 = ""
	цикл для всех из 50-й школы
		s = Ф. И. ученика из 50-й школы
		если ball > max1 то
			max2 = max1
			max1 = ball
			n2 = n1
			n1 = 1
			s2 = s1
			s1 = s
		иначе если ball = max1 то
			max2 = ball
			n1 = n1 + 1
			s2 = s
		иначе если ball = max2 то
			max2 = ball
			n2 = 1
			s2 = s
		иначе если ball = max2 то
			n2 = n2 + 1
	

Аналогично, оператор последнего условия не содержит присваивания имени потому, что ранее оно уже было присвоено корректным значением.

Вывод результатов

Двое лучших – это либо два одинаковых максимальных балла, либо один максимум и один второй максимум. Один лучший – это когда один победитель, а количество вторых максимумов более одного. В остальных случаях получим вывод, в котором количество максимумов – больше двух:

	если n1==1 и n2==1 или n1==2 то
		печать s1, s2
	иначе если n1==1 и n2>1 то
		печать s1
	иначе
		печать n1

Цикл по всем ученикам

Переходим на Python. Найдём количество учеников из всех школ. Если данные нашей задачи хранятся в файле, то первая строка файла содержит это значение. Вот как можно подключиться к файлу, а затем извлечь всех учеников в переменную N:

	f = open("имяфайла.txt", encoding='utf-8', mode="r")
	N = f.readline()
	

N, нам понадобится для организации цикла по всем ученикам:

	for i in range(int(N))

Ученик из 50-й школы

После N идут строки со значениями, значения разделены пробелом. Функция split разбивает каждую прочитанную строку в массив подстрок:

	array = f.readline().split()

Откуда: array[0] – первая подстрока с фамилией, array[1] – вторая подстрока с именем, array[2] – номер школы и наконец, array[3] – набранный балл. Теперь проверить 50-ую школу можно так:

	school = int(array[2])
	if school == 50:

Фамилия и имя получается сложением:

	s = array[0] + " " + array[1]

Полный код на Python

  f = open("11C4v01.txt", encoding='utf-8', mode="r")
  n = int(f.readline())
  max1 = max2 = -1
  n1 = n2 = 0
  s1 = s2 = ""
  for i in range(n):
      a = f.readline().split()
      #a[0] - Фамилия
      #a[1] - Имя
      #a[2] - номер школы [1..99]
      #a[3] - балл ученика(цы)
      s = a[0] + " " + a[1]
      school = int(a[2])
      ball = int(a[3])
      if school == 50:
          if ball > max1:
              max2 = max1
              max1 = ball
              n2 = n1
              n1 = 1
              s2 = s1
              s1 = s
          elif ball == max1:
              max2 = ball
              n1 += 1 
              s2 = s
          elif ball > max2:
              max2 = ball
              n2 = 1
              s2 = s
          elif ball == max2:
              n2 += 1
  # Вывод результатов
  if n1==1 and n2==1 or n1==2:
      print (s1, " ",s2)
  elif n1==1 and n2>1:
      print(s1)
  else:
      print(n1)
  f.close()

После единых выпускных экзаменов по информатике в район пришла информация о том, какой ученик, какой школы сколько набрал баллов.

Районный методист решила выяснить номер школы, ученики которой набрали наибольший средний балл, с точностью до целых.

Программа должна вывести на экран номер такой школы и её средний балл.

Если наибольший средний балл набрало больше одной школы — вывести количество таких школ.

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например, Borland Pascal 7.0), которая должна вывести на экран требуемую информацию. Известно, что информатику сдавало больше 5-ти учеников района. Также известно, что в районе школы с некоторыми номерами не существуют.

На вход программе сначала подаётся число учеников, сдававших экзамен. В каждой из следующих N строк находится информация об учениках в формате:

<Фамилия> <Имя> <Номер школы> <Количество баллов>

где <Фамилия> — строка, состоящая не более, чем из 30 символов без пробелов, <Имя> — строка, состоящая не более, чем из 20 символов без пробелов, <Номер школы> — целое число в диапазоне от 1 до 99, <Количество баллов> — целое число диапазоне от 1 до 100. Эти данные записаны через пробел, причём ровно один между каждой парой (то есть, всего по три пробела в каждой строке).

Пример входной строки:
Иванов Иван 50 87
Пример выходных данных:
50 74
Другой вариант выходных данных:
7

Решение:

Сумма баллов

Пусть количество школ 3, а количество учеников 6 (N=6). И пусть будут такими номера школ и баллы учеников:

2 6

3 15

1 8

2 10

3 9

2 7

Просуммировать баллы по каждой школе удобно с помощью массива, размер которого равен количеству школ:

Получаем такой массив после суммирования:

Алгоритм суммирования массива баллов:

	Цикл для i от 0 до 5 учеников
		m = № школы из i-й строки данных
		ball = балл ученика m-й школы
		sum[m] = sum[m] + ball
	

Данные массива sum после выполнения алгоритма:

sum[0]=8

sum[1]=23

sum[2]=24

Средний бал

Средний балл = сумма баллов школы/количество учеников школы.

где числитель – это массив из пункта Сумма баллов, а знаменатель – это ещё один массив такого же размера, только каждый элемент этого массива – это количество учеников в конкретной школе. Другими словами, знаменатель – это количество плюсов на схеме из пункта Сумма баллов. Значит, во время суммирования баллов каждой школы, увеличиваем на 1 i-й элемент второго массива:

	Цикл для i от 0 до 5 учеников
		m = № школы из i-й строки данных
		ball = балл ученика m-й школы
		sum[m] = sum[m] + ball
		cnt[m] = cnt[m] + 1
	

Данные массива sum и cnt после выполнения алгоритма:

sum[0]=8

sum[1]=23

sum[2]=24

cnt[0]=1

cnt[1]=3

cnt[2]=2

Ну, а теперь вычисление среднего балла. Для этого понадобится ещё один цикл, но уже по школам:

	Цикл для i от 0 до 2 школ
		sum[i] = sum[i] / cnt[i]
	

Данные массива sum после выполнения алгоритма:

sum[0]=8

sum[1]=7,66

sum[2]=12

Однако мы не учли отсутствие номеров некоторых школ. Это значит, что массивы sum и cnt где-то содержат нули – будет деление на ноль. Полный код на Python учтёт это.

Поиск лучших школ

По условию лучших школ может быть либо одна, либо две и более. В первом случае нужно сохранить номер школы и средний балл – это обычный поиск максимума:

	max = sum[0] ;сохраняем в max ср.балл школы №1
	n = 0 ;номер школы, пока 0
	Цикл для i от 1 до 2 школ ;начинаем со школы №2
		если sum[i] > max то
			max = sum[i]
			n = i;сохраняем в n № школы
	

Во втором случае нужно сохранить количество школ. Это сравнение на равенство среднего балла текущей школы с сохранённым ранее максимальным средним баллом – max :

	max = sum[0] ;сохраняем в max ср.балл школы №1
	n = кол-во = 0 ;номер школы и кол-во учеников, пока 0
	Цикл для i от 1 до 2 школ ;начинаем со школы №2
		если sum[i] > max то
			max = sum[i]
			кол-во = 1
			n = i   ;сохраняем в n № школы
		иначе если sum[i] = max то
			кол-во = кол-во + 1
	

Нужно написать эффективную по памяти программу, для этого можно исключить переменную n. Тогда в max сохранять не значение среднего балла первой школы(sum[0]), а индекс самой школы, затем произвести изменения в условном операторе. Это будет сделано в полном коде на Python.

Вывод результатов

Проверяем количество лучших школ, если лучшая школа одна, то выводим номер школы и её средний балл. В остальных случаях выводим количество:

	если кол-во = 1 то
		печать n max
	иначе
		печать кол-во
	

Полный код на Python

  f = open("11C4v01.txt", encoding='utf-8', mode="r")
  n = int(f.readline())
  nsch = 99 #кол-во школ [1..99]
  sum = [0] * nsch # массив суммарных баллов по каждой школе
  cnt = [0] * nsch # массив количеств учеников в каждой школе

  #суммируем баллы и считаем кол-во учеников по каждой школе
  for i in range(n):
    #a[0] - Фамилия (она не нужна)
    #a[1] - Имя (оно не нужно)
    #a[2] - номер школы [1..99]
    #a[3] - балл ученика(цы)
      a = f.readline().split()
      isch = int(a[2])-1 # isch - [0..98]
      sum[isch] += int(a[3])
      cnt[isch] += 1

  #средний балл
  for i in range(nsch):
#из-за отсутствия номеров некоторых школ, избегаем деления на 0
      if cnt[i]>0:
          sum[i] = sum[i] / cnt[i]

  #Поиск лучших школ
  max = 0
  n = 0
  for i in range(1,nsch):
      if sum[i] > sum[max]:
          max=i
          n=1
      elif sum[i] == sum[max]:
          n += 1
  
  #Вывод результатов
  if n == 1:
      print(max+1," ",sum[max])
  else:
      print(n)

После единых выпускных экзаменов по информатике в район пришла информация о том, какой ученик какой школы сколько баллов набрал.

Районный методист решила выяснить номера школ, ученики которых набрали средний балл по школе, больший, чем районный средний балл (все средние баллы вычисляются с точностью до целых).

Программа должна вывести на экран номера таких школ, в любом порядке.

Если такая школа окажется только одна — вывести также средний балл по этой школе, с указанием, что это средний балл.

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например Borland Pascal 7.0), которая должна вывести на экран требуемую информацию. Известно, что информатику сдавало больше 5-ти учеников района. Также известно, что в районе школы с некоторыми номерами не существуют.

На вход программе сначала подаётся число учеников, сдававших экзамен. В каждой из следующих N строк находится информация об учениках в формате:

<Фамилия><Имя><Номер школы><Количество баллов>

где <Фамилия> — строка, состоящая не более чем из 30 символов без пробелов, <Имя> — строка, состоящая не более чем из 20 символов без пробелов, <Номер школы> — целое число в диапазоне от 1 до 99, <Количество баллов> — целое число в диапазоне от 1 до 100. Эти данные записаны через пробел, причём ровно один между каждой парой (то есть, всего по три пробела в каждой строке).

Пример входной строки:
Иванов Иван 50 87
Пример выходных данных:
5 50 74 87
Другой вариант выходных данных:
7
Средний балл = 74

Решение:

Средние баллы по району и школе

Cр.балл по району = Все баллы / N

Средний балл по школе = Сумма баллов по школе / кол-во учеников школы

Сумму баллов по школе получаем как в примере 2011 С4 №2: создаём массив sum из 99 элементов(кол-во школ), заносим сумму баллов школы в каждый элемент. Добавим подсчёт кол-ва учеников в массив cnt:

	Цикл для i от 0 до N-1
		m = № школы из i-й строки данных
		ball = балл ученика m-й школы
		sum[m] = sum[m] + ball ;суммы баллов по m-ой школе
		cnt[m] = cnt[m] + 1 ;кол-во учеников m-ой школы

Заметим, что вместо вычисления всех баллов, можно просуммировать суммы баллов по школе в отдельную переменную. Тем самым избавиться от лишнего суммирования N раз!

Т.к. некоторых номеров школ нет, то соответствующие элементы массивов sum и cnt содержат нули. Для этого нужно следить, чтобы, при вычислении среднего, не было деления на ноль:

	avg = 0 ;переменная для всех баллов
	Цикл для i от 0 до 98 школ
		если sum[i] > 0 то
		avg = avg + sum[i] ;суммируем все баллы
		sum[i] = sum[i] / cnt[i]  ;средний балл по школе

Обратим внимание на две строки условия. Сначала суммируем баллы всех школ. Затем на место суммы баллов по школе, помещаем средний балл по этой же школе – тем самым не создаём лишнюю переменную для среднего значения.

Средний балл по району:

	avg = avg / N

Вывод результатов

Вывод номера или номеров школ проведём с помощью сравнения среднего балла по школе со средним баллом по району. Если балл по школе больше балла по району, то выведем её номер:

	Цикл для i от 0 до 98 школ
		если sum[i] > avg то
			печать i

Ну, а если школа единственная, то нужна переменная n, которая посчитает кол-во сравнений и переменная ball, которая сохранит балл этой единственной школы:

	m=0
	Цикл для i от 0 до 98 школ
		если sum[i] > avg то
			m = m + 1
			ball = sum[i]	
			печать i
	если m = 1 то
		печать "Средний балл:" ball			

Полный код на Python

  f = open("11C4v01.txt", encoding='utf-8', mode="r")
  n = int(f.readline())
  nsch=99 # кол-во школ [1..99]
  sum = [0] * nsch # массив суммарных баллов по каждой школе
  cnt = [0] * nsch # массив количеств учеников в каждой школе

  #суммируем баллы и считаем кол-во учеников по каждой школе
  for i in range(n):
      #a[0] - Фамилия (она не нужна)
      #a[1] - Имя (оно не нужно)
      #a[2] - номер школы [1..99]
      #a[3] - балл ученика(цы)
      a = f.readline().split()
      isch = int(a[2])-1 # isch - [0..98]
      sum[isch] += int(a[3])
      cnt[isch] += 1

  #средний балл по школе
  avg = 0
  for i in range(nsch):
    if cnt[i] > 0:
        avg = avg + sum[i]  # суммируем все баллы
        sum[i] = sum[i] / cnt[i] # средний балл по школе

  #средний балл по району
  avg /= n

  #Вывод результатов
  m = 0
  for i in range(nsch):
      if sum[i] > avg:
          m += 1
          ball = sum[i]
          print(i+1, end=' ')
  if m == 1:
      print("Средний балл:",ball)
	

После единых выпускных экзаменов по информатике в район пришла информация о том, какой ученик какой школы сколько набрал баллов.

Районный методист решила выяснить фамилии учеников, которые набрали наибольший балл, по каждой школе в отдельности, но только если из школы информатику сдавало не меньше трёх человек. Если в школе информатику сдавало меньше трёх человек, информацию по этой школе выводить не нужно. Если наибольший балл в какой-то школе набрали несколько человек, нужно вывести на экран их количество.

Программа должна вывести на экран информацию в виде:

<Номер школы> <Фамилия ученика>

где <Фамилия> — строка, состоящая не более чем из 30 символов без пробелов, <Имя> — строка, состоящая не более чем из 20 символов без пробелов, <Номер школы> — целое число в диапазоне от 1 до 99, <Количество баллов> — целое число в диапазоне от 1 до 100. Эти данные записаны через пробел, причём ровно один между каждой парой (то есть, всего по три пробела в каждой строке).

в отдельной строке для каждой школы.

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например Borland Pascal 7.0), которая должна вывести на экран требуемую информацию. Известно, что информатику сдавало больше 5-ти учеников района. Также известно, что в районе школы с некоторыми номерами не существуют.

На вход программе сначала подаётся число учеников, сдававших экзамен. В каждой из следующих N строк находится информация об учениках в формате:

<Фамилия> <Имя> <Номер школы> <Количество баллов>

где <Фамилия> — строка, состоящая не более чем из 30 символов без пробелов, <Имя> — строка, состоящая не более чем из 20 символов без пробелов, <Номер школы> — целое число в диапазоне от 1 до 99, <Количество баллов> — целое число в диапазоне от 0 до 100. Эти данные записаны через пробел, причём ровно один между каждой парой (то есть всего по три пробела в каждой строке).

Пример входной строки:
Иванов Иван 50 87
Пример выходных данных:
5 Иванов
50 10
74 Сидоров

Решение:

Количество учеников сдававших экзамен в школе

Каждая строка данных содержит номер школы, который мы присвоим в переменную m. Эта m будет индексом массива cnt, который будем использовать для хранения кол-ва учеников в школе номером m:

    cnt [99] ;кол-во учеников в школе
    Цикл для i от 0 до N-1 ;цикл по строкам данных
        m = № школы из i-й строки данных
        ;считаем кол-во учеников в m-й школе
        cnt[m] = cnt[m] + 1

Т.о., каждый элемент массива cnt – это кол-во учеников в школе, номер которой есть индекс элемента

Наибольший балл

Вспомним пример ЕГЭ 2011 С4 №1, первая часть пункта Выбор лучших. Только здесь понадобится сохранять не одно лучшее значение, а лучшие значения для каждой школы: в массиве bal:

    bal [99] ;кол-во учеников в школе
    Цикл для i от 0 до N-1 ;цикл по строкам данных
        m = № школы из i-й строки данных
        ball = балл ученика m-й школы
        если ball > bal[m] то
            bal[m] = ball

Количество лучших учеников

Продолжаем воспоминания примера ЕГЭ 2011 С4 №1 второй части пункта Выбор лучших, и добавим вторую ветку нашему алгоритму. В ней, в массиве amt, будем считать количество одинаковых максимальных баллов школы номером m.

    bal [99] ;кол-во учеников в школе
    amt [99] ;кол-во лучших в школе
    Цикл для i от 0 до N-1 ;цикл по строкам данных
        m = № школы из i-й строки данных
        ball = балл ученика m-й школы
        если ball > bal[m] то
            bal[m] = ball
            amt[m] = 1 ;кол-во лучших в школе m пока 1
        иначе если ball = bal[m] то
            amt[m] = amt[m] + 1 ;считаем кол-во лучших в школе m

Имена

Такой же пункт Имена как в примере ЕГЭ 2011 С4 №1, а в нашей задаче нужно учесть только фамилию, если лучший в школе единственный:

    bal [99] ;наибольший балл в школе
    amt [99] ;кол-во лучших в школе
    nam [99] ;фамилия одного лучшего в школе
    Цикл для i от 0 до N-1
        m = № школы из i-й строки данных
        ball = балл ученика m-й школы
        s = фамилия ученика m-й школы
        если ball > bal[m] то
            bal[m] = ball
            amt[m] = 1
            nam[m] = s
        иначе если ball = bal[m] то
            amt[m] = amt[m] + 1

Алгоритмы, которые мы рассмотрели, выполняются в одном цикле. В полном коде мы их объединим в один.

Вывод результатов

Нужно вывести два значения: номер школы и либо фамилию, в случае одного лучшего в школе, либо количество лучших, если таковых несколько:

	Цикл для i от 0 до 98 школ
        если сnt[i] > 2 то
            если amt[i] = 1 то
                печать i nam[i] ;номер школы и имя лучшего
            иначе
                печать i amt[i] ;номер школы и кол-во лучших

Полный код на Python

  f = open("11C4v01.txt", encoding='utf-8', mode="r")
  n = int(f.readline())
  nsch = 99 #кол-во школ [1..99]
  cnt = [0] * nsch #кол-во учеников в школе
  bal = [0] * nsch #наибольший балл в школе
  amt = [0] * nsch #кол-во лучших учеников в школе
  nam = [''] * nsch #фамилия одного лучшего в школе

#суммируем баллы и считаем кол-во учеников по каждой школе
  for i in range(n):
      #a[0] - Фамилия
      #a[1] - Имя, оно не нужно
      #a[2] - номер школы [1..99]
      #a[3] - балл ученика(цы)
     a = f.readline().split()
     m = int(a[2])-1 #isch - [0..98]
     ball = int(a[3])
     if  ball > bal[m]:
        bal[m] = ball
        amt[m] = 1
        nam[m] = a[0]
    else:
        amt[m] += 1
    #считаем кол-во учеников в m-й школе
    cnt[m] += 1

#Вывод результатов
  m = 0
  for i in range(nsch):
     if cnt[i] >= 3:
        if amt[i] == 1:
           print(i+1," ", nam[i])
        else:
           print(i+1, " ", amt[i])

После единых выпускных экзаменов по информатике в район пришла информация о том, какой ученик, какой школы сколько баллов набрал.

В районе считается подозрительной ситуация, когда в школе более двух учащихся набирают одинаковый наибольший балл по школе.

Районный методист решила выяснить номера таких школ.

Программа должна вывести номера этих школ, в любом порядке.

Если такая школа окажется одна, нужно вывести наибольший балл в этой школе, с указанием того, что это наибольший балл.

Если таких школ не окажется, нужно вывести об этом сообщение.

Напишите эффективную, в том числе и по используемой памяти, программу, которая должна вывести на экран требуемую информацию. Известно, что информатику сдавало больше 5-ти учеников района. Также известно, что в районе школы с некоторыми номерами не существуют.

На вход программе сначала подаётся число учеников, сдававших экзамен. В каждой из следующих N строк находится информация об учениках в формате:

<Фамилия> <Имя> <Номер школы> <Количество баллов>

где <Фамилия> — строка, состоящая не более чем из 30 символов без пробелов, <Имя> — строка, состоящая не более, чем из 20 символов без пробелов, <Номер школы> — целое число в диапазоне от 1 до 99, <Количество баллов> — целое число в диапазоне от 0 до 100. Эти данные записаны через пробел, причём ровно один между каждой парой (то есть, всего по три пробела в каждой строке).

Пример входной строки:
Иванов Иван 50 87
Пример выходных данных:
5 50 74 87
Другой вариант выходных данных:
7
Наибольший балл = 74
Третий вариант выходных данных:
Нет таких школ

Решение:

Поиск максимума в каждой школе и подсчёт их совпадений

Подобное было в С4 2011 №1 и №4. Каждая строка данных содержит номер школы, который мы присвоим переменной m. Её значение будет индексом массивов bal и amt. Массив bal хранит наибольший балл школы номером m, а массив amt – кол-во учеников школы номером m с наибольшим баллом:

    bal [99] ;наибольший балл в школе
    amt [99] ;кол-во одинаковых лучших учеников в школе
    Цикл для i от 0 до N-1 ;по строкам данных
        m = № школы из i-й строки данных
        ball = балл ученика m-й школы
        если ball > bal[m] то
            bal[m] = ball
            amt[m] = 1
        иначе если ball = bal[m] то
            amt[m] = amt[m] + 1

Вывод результатов

Массивы bal и amt заполнили, теперь посчитаем кол-во «подозрительных» школ: если их несколько, то выведем их номера; если их нет, то выведем сообщение; если она одна, то выведем номер школы и наибольший балл. Подсчёт «подозрительных» школ будем вести в переменную k:

    k = 0 ;кол-во подозрительных школ
    Цикл для i от 0 до 99 ; по всем школам
        если amt[i] > 2 то
            ball = bal[i] ;для случая когда k=1
            печать i " " ;номер подозрительной школы и пробел
            k = k + 1
    ;после того как прошлись по школам, рассмотрим два случая
    если k = 0 то ;когда подозрительных школ нет
        печать "таких школ нет"
    иначе если k = 1 то ;и когда подозрительная школа одна
        печать  ;перешли на следующую строку
        печать "Наибольший балл:" ball

Полный код на Python

  f = open("11C4v01.txt", encoding='utf-8', mode="r")
  n = f.readline()
   nsch = 99 #кол-во школ [1..99]
   bal = [0] * nsch #массив наибольших баллов по каждой школе
   #массив количеств одинаковых лучших учеников в школе
   amt = [0] * nsch 

   #суммируем баллы и считаем кол-во учеников по каждой школе
   for i in range(int(n)):  
      #a[0] - Фамилия (она не нужна)
      #a[1] - Имя (оно не нужно)
      #a[2] - номер школы [1..99]
      #a[3] - балл ученика(цы)
  
  
  a = f.readline().split()
  m = int(a[2])-1 #m - [0..98]
  ball = int(a[3])

  if ball > bal[m]:
     bal[m] = ball
     amt[m] = 1
  elif ball == bal[m]:
     amt[m] += 1
   #Вывод результатов
   k = 0
   for i in range(nsch):
   if amt[i] > 2:
       ball = bal[i]
  print(i + 1, end=' ') #номер подозрительной школы
  k += 1
   if k == 0:
       print(" Таких школ нет")
   elif k == 1:
       print() #перешли на следующую строку
       print("Наибольший балл:", ball)

При программировании школьной тестирующей системы по английскому языку выяснилось, что файлы с вопросами к тестам легко доступны и каждый может перед тестом открыть их и заранее узнать вопросы. Было решено закодировать файлы. Для этого придумали следующий алгоритм.

Каждая строка файла кодируется отдельно.

В каждой строке ищутся отдельные слова, и все символы слова сдвигаются по алфавиту циклически вправо на длину слова.

Словом считается любая последовательность подряд идущих символов латинского алфавита, строчных и прописных.

Циклический сдвиг символа по алфавиту вправо на X — замена символа на символ, стоящий в алфавите на X позиций дальше. Если при этом происходит выход за пределы алфавита, счёт начинается с начала алфавита.

Пример циклического сдвига символов на 3 позиции: буква «Е» превращается в букву «Н», буква «t» — в букву «w» буква «Y» — в букву «В».

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например Borland Pascal 7.0), которая должна закодировать строку по указанному алгоритму.

На вход программе подается строка, состоящая из не более чем 250 символов латинского алфавита, пробелов, знаков препинания, разного рода скобок, кавычек и других символов. Строка заканчивается символом «#». Других символов «#» в строке нет.

Программа должна вывести закодированную по указанному алгоритму строку.

Пример входных данных:
Day, mice. «Year» — a mistake#
Пример выходных данных:
Gdb, qmgi. «Ciev» — b tpzahrl#

Решение:

Длина слова

Чтобы сдвинуть символы на длину слова, нужно знать её величину. Посчитаем длину каждого слова строки s:

    s = "…" ;строка со словами и другими символами
    n = длина строки s
    flag = ЛОЖЬ
    Для i от 1 до n ;по каждому символу строки s
        если s[i] буква то;буква-не буква
            если flag то
                len = len + 1
            иначе
                len = 1
                flag = ИСТИНА

После этого алгоритма значение len будет иметь длину слова, а значение i – позицию последнего символа слова. Так что, в стиле Python – [(i-len):i] будет слово из массива.

Двигаем символы

Когда мы достигли последнего символа в слове, самое время сдвинуть каждый его символ:

    …
        если s[i] буква то;буква-не буква
            …
        иначе
            если flag то
                flag = ЛОЖЬ
                Для k от 1 до len ;по каждому символу слова
                    если s[i-k] + len  выходит за алфавит то 
                        s[i-k] = s[i-k] + len – 26 
                    иначе 
                        s[i-k] = s[i-k] + len
    печать s 

Переменная flag отвечает за начало подсчёта символов слова в первой ветке условия – «буква-не буква», а во второй ветке – за то, чтобы сдвиг символов в слове был только один раз.

Полный код на Python

   s = "Bike, Zip, Roller, 1345asdfads#"
   total = len(s)
   n = 0
   flag = False

   for i in range(total):
      c = s[i]
      if c.isalpha():
         if flag == False:
            len = 1
            flag = True
          else:
             len += 1
      elif flag == True:
         flag = False
         stmp = ""
         for k in range(len):
            #i-len - возврат к первому симолу слова
            if ord(s[i-len + k].upper()) - ord("A") + len > 25:
               stmp += chr(ord(s[i - len + k]) + len - 26 )
            else:
               stmp += chr(ord(s[i - len + k]) + len )
      #замена одной подстроки на другую
      s = s.replace(s[i - len:i], stmp) 

   print (s)
 

После единых выпускных экзаменов по информатике в район пришла информация о том, какой ученик какой школы сколько баллов набрал. По положению об экзамене каждый район сам определяет, за какой балл нужно поставить какую оценку.

Районный методист решила, что оценку «отлично» должны получить 20% участников (целое число, с отбрасыванием дробной части).

Для этого она должна определить, какой балл должен был набрать ученик, чтобы получить «отлично».

Если невозможно определить такой балл, чтобы «отлично» получили ровно 20% участников, «отлично» должно получить меньше участников, чем 20%.

Если таких участников не окажется (наибольший балл набрали больше 20% участников) — эти и только эти ученики должны получить «отлично».

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например Borland Pascal 7.0), которая должна вывести на экран наименьший балл, который набрали участники, получившие «отлично». Известно, что информатику сдавало больше 5-ти учеников. Также известно, что есть такое количество баллов, которое не получил ни один участник.

На вход программе сначала подаётся число учеников, сдававших экзамен. В каждой из следующих N строк находится информация об учениках в формате:

<Фамилия> <Имя> <Номер школы> <Количество баллов>

где <Фамилия> — строка, состоящая не более чем из 30 символов без пробелов, <Имя> — строка, состоящая не более чем из 20 символов без пробелов, <Номер школы> — целое число в диапазоне от 1 до 99, <Количество баллов> — целое число в диапазоне от 1до 100. Эти данные записаны через пробел, причём ровно один между каждой парой (то есть всего по три пробела в каждой строке).

Пример входных данных:
Иванов Иван 50 87
Пример выходных данных:
78

Решение:

Количество оценок

Посчитаем кол-во каждых оценок:

	k[100] ;кол-во оценок
	Для i от 0 до N-1 ;цикл по строкам данных
		ball = оценка из i-й строки данных 
		k[ball] = k[ball] + 1 ;считаем кол-во оценок

Индекс массива k – это конкретная оценка, а его элемент будет хранить кол-во этих оценок.

Количество лучших из 20% участников

Критерий – это 20% от N. Если суммировать оценки, например, в переменную s, то можно получить кол-во лучших оценок равное 20% или более

	s = 0 ;кол-во оценок
	i = 99 ;начинаем с самой высокой оценки, её индекс = 99
	p = N DIV 5 ;p – 20% от N
	Пока s < p  ;цикл по
		s = s + k[i]
		i = i – 1 ;спускаемся к следующей оценке

После этого цикла i будет содержать значение оценки

Возможные варианты

Рассмотрим некоторые варианты разного количества лучших оценок. Для простоты, диапазон оценок [1;5].

1. N=10 (p=2) из них две пятёрки: k = [? ? ? ? 2] или одна пятёрка, и одна четвёрка: k = [? ? ? 1 1]. В 1-м случае нужно вывести оценку 5, а во 2-м – 4. После алгоритма выше, s = 2. Тогда, для нужного вывода, достаточно условия на равенства p с s :

	s = 0 ;кол-во оценок
	i = 99 ;начинаем с самой высокой оценки, её индекс = 99
	p = N DIV 5 ;p – 20% от N
	Пока s < p  ;цикл по
		s = s + k[i]
		i = i – 1 ;спускаемся к следующей оценке
	если s = p то
		печать i

аналогично, для N=20 (p=4) получим такие выводы для соответствующих последовательностей:

k = [? ? ? ? 4] печать 5

k = [? ? ? 3 1] = [? ? ? 2 2] = [? ? ? 1 3] печать 4

k = [? ? 2 1 1] = [? ? 2 2 0] = [? ? 2 0 2] печать 3

и т. д.

2. N=20 (p=4) из них три пятёрки и две четвёрки: k = [? ? ? 2 3] или наоборот [? ? ? 3 2]. s = 5, т.е. больше p. По условию нужно выводить либо ровно 20%, либо меньше чем 20%. Тогда для этих двух последовательностей, выводим не четвёрку, а пятёрку. Значит, увеличим i на 1:

	s = 0 ;кол-во оценок
	i = 99 ;начинаем с самой высокой оценки, её индекс = 99
	p = N DIV 5 ;p – 20% от N
	Пока s < p  ;цикл по
		s = s + k[i]
		i = i – 1 ;спускаемся к следующей оценке
	если s = p то
		печать i
	иначе
		i = i + 1 ;возвращаемся к пятёркам
		печать i

По условию некоторых баллов не набрал никто, например, четвёрок: k = [? ? 2 0 3]. Новый алгоритм выше на выводе даст значение 0. Исключим нулевое/вые вхождения:

	иначе
		i = i + 1 ;возвращаемся к пятёркам
		Пока k[i]=0 ;встретили нулевую оценку
			i = i + 1 ;уходим от нулевой оценки
		печать i

3. Последнее, когда одно значение баллов, и оно больше 20%: N=10 (p=2) k = [? ? ? ? 3] печать 5. Здесь значение s должно быть равно k[i]:

	иначе
		если s=k[i] то
			печать i
		иначе
			i = i + 1
			Пока k[i]=0
				i = i + 1
			печать i

Полный код на Python

   f = open("11C4v01.txt", encoding='utf-8', mode="r")
   n = int(f.readline())
   k = [0] * 100 #кол-во оценок
   for i in range(n):
      #a[0] - Фамилия (она не нужна)
      #a[1] - Имя (оно не нужно)
      #a[2] - номер школы [1..99] (он не нужен)
      #a[3] - балл ученика(цы)	  
      a = f.readline().split()
      iball = int(a[3]) - 1 #iball - [0..99]
      k[iball] += 1

   p = n // 5
   s = 0
   i = 100
   while s &lt p:
      i = i - 1
      s = s + k[i]
   if s == p:
      print(i+1)
   else:
      if k[i] == s:
         print(i+1)
      else:
         i = i + 1
         while k[i] == 0:
            i = i + 1
         print(i+1)

После единых выпускных экзаменов по информатике в район пришла информация о том, какой ученик какой школы сколько баллов набрал. По положению об экзамене оценку “2” (неудовлетворительно) получают ученики, набравшие меньше 40 баллов. Оценку “3” (удовлетворительно) получают 30% учеников среди оставшихся, за исключением тех из них, кто набрал больше 60 баллов.

Если количество “троечников” оказывается больше 30%, то следует выбрать меньшую границу для оценки “4” (но только если при этом “3” получит хоть кто-нибудь).

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например, Borland Pascal 7.0), которая должна вывести на экран наибольший балл, который набрали участники, получившие “удовлетворительно” и количество таких учеников. Известно, что информатику сдавало больше 50-ти учеников. Также известно, что есть такое количество баллов, которое не получил ни один участник.

На вход программе сначала подаётся число учеников, сдававших экзамен. В каждой из следующих N строк находится информация об учениках в формате:

<Фамилия> <Имя> <Номер школы> <Количество баллов>

где <Фамилия> — строка, состоящая не более, чем из 30 символов без пробелов, <Имя> — строка, состоящая не более, чем из 20 символов без пробелов, <Номер школы> — целое число в диапазоне от 1 до 99, <Количество баллов> — целое число диапазоне от 1 до 100. Эти данные записаны через пробел, причем ровно один между каждой парой (то есть, всего по три пробела в каждой строке).

Пример входных данных:
Иванов Иван 50 87
Пример выходных данных:
78

Решение:

Количество оценок

Аналогично 2011 С4 № 7 – посчитаем кол-во каждых оценок:

	k[100] ;[1..100] кол-во оценок
	Для i от 0 до N-1 ;цикл по строкам данных
		ball = оценка из i-й строки данных 
		k[ball] = k[ball] + 1 ;считаем кол-во оценок

Индекс массива k – это конкретная оценка, а элемент этого индекса будет хранить кол-во этих оценок.

Количество двоечников и 30% от не двоечников

Посчитаем кол-во двоечников, затем мы их исключим из общего кол-ва учеников:

	s = 0 ;кол-во двоечников
	Для i от 1 до 39 ;первые 39 строк массива с оценками
		s = s + k[i] ;суммируем всех двоечников
	p = (N - s) * 30 DIV 100 ;30% от не двоечников

Кол-во троечников

В 2011 С4 №7 мы искали только 20% лучших, значит критерий поиска был простым: s &lt p. Теперь нужно искать не более 30% троечников и у них максимальный балл 60, значит критерий будет составным:

	s = 0 i = 40 ;сбрасываем сумму и начинаем с троечников
	Пока s < p И i < 61  ;составной критерий для троечников
		i = i + 1 ;переходим к следующей оценке
		s = s + k[i];суммируем всех троечников

Возможные варианты

Рассмотрим некоторые варианты разного количества троечников.

1. Кол-во троечников составляет ровно 30%, и их максимальный балл меньше 60:

	Пока s < p И i < 61  ;составной критерий для троечников
		i = i + 1 ;переходим к следующей оценке
		s = s + k[i];суммируем всех троечников
	если s = p то ;кол-во 3-ков 30% и их макс балл < 60
		;максимальная оценка и кол-во таких оценок
		печать i s

2. Кол-во троечников меньше 30%, и их максимальный балл равен 60:

	иначе если i = 60 И s < p то
		;максимальная оценка и кол-во таких оценок
		печать 60 s
   

Но! Если максимальный балл будет меньше чем 60, программа всё равно выведет 60… (в этом место нужно доработать).

3. Троечники набравшие более 30% и какой-то один одинаковый:

	иначе если  s = k[i] то
		;максимальная оценка и кол-во таких оценок
		печать i s

4. Остальные троечники набравшие более 30% неодинаковые баллы:

	;убираем троечников, которые вышли за допустимую границу
	s = s - k[i]
	i = i – 1
	Пока k[i]=0
		i = i - 1
	печать i s ;максимальная оценка и кол-во таких оценок

Подобный алгоритм описан в В 2011 С4 v07, только там, для избавления от отсутствующих оценок, нужно перемещаться в другую сторону массива оценок.

Полный код на Python

  f = open("11C4v01.txt", encoding='utf-8', mode="r")
  n = int(f.readline())
  k = [0] * 100 #кол-во оценок
  for i in range(n):
	#a[0] - Фамилия (она не нужна)
	#a[1] - Имя (оно не нужно)
	#a[2] - номер школы [1..99] (он не нужен)
	#a[3] - балл ученика(цы)
	a = f.readline().split()
	iball = int(a[3]) - 1 #iball - [0..99]
	k[iball] += 1
  s = 0
  i = 0
  for i in range(39): #[0..38] т.е. первые 39 баллов
	s = s + k[i]
  print("i:",i," s:",s)
  p = (n-s)*30 // 100
  s = 0
  
  #старое значение i=38, а троечники начинаются с 39,
  зн. увеличим i на 1 до обращения к массиву k:
  while s < p and i < 59: #здесь 60 это индекс 61-го балла!
	i = i + 1
	s = s + k[i]

  if s == p:
	print(i+1," ",s)

  elif i == 59 and s < p:
	#выведет 60 даже если максимальный балл троечников < 60
	print("60", s)

  elif s == k[i]:
	print(i + 1, " ", s)
  else:
	s -= k[i]
	i -= 1
  while k[i] == 0:
	i -= 1
  print(i + 1, " ", s)

На вход программе подается последовательность символов, заканчивающаяся символом #. Другие символы # во входной последовательности отсутствуют.

Программа должна вывести на экран латинскую букву встречающуюся во входной последовательности наибольшее количество раз (во второй строке).

Если таких букв во входной последовательности окажется несколько, программа должна вывести на экран всех, через пробел, в алфавитном порядке.

Строчные и прописные буквы не различаются.

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например Borland Pascal 7.0), которая должна решать поставленную задачу.

Пример входных данных:
Day, mice. «Year» — a mistake#
Пример выходных данных:
A
4

Решение:

Количество каждой буквы в строке

    s = "…" ;строка со словами и другими символами
    n = длина строки s
    num[26] ;массив количества латинских букв алфавита
    Для i от 1 до n ;по каждому символу строки s
        если s[i] буква то ;буква-не буква
            k = номер буквы
            ;увеличиваем счётчик количества таких букв
            num[k] = num[k] + 1

Найдём максимум и их количество

Найдём буквы, встречающиеся наибольшее количество раз, и число этих раз в массиве s:

    ic = 0 ;индекс первой буквы ('A') в массиве num
    k = 1 ;счётчик количества максимумов в массиве num
    Для i от 1 до 26 ;от 'B' до 'Z'
        если num[i] > num[ic] то ; находим максимум
            ic = i ;индекс первой буквы меняем на индекс второй
            k = 1
        иначе если num[i] = num[ic] то ;такой же максимум
            k = k + 1 ;увеличиваем счётчик кол-ва максимумов

Вывод результатов

    если k = 1 то ;если максимум один
        печать ic ;символ ic
    иначе
    Для i от 0 до 26 ;от 'A' до 'Z'
        если num[i] = num[ic] то
            печать i ' ' ;символ i
    печать num[ic] ;кол-во максимумов
			

Полный код на Python

   #s = "Day, mice. 'Year' - a mistake#"
   s = "ABCD ABCE ABCF#"
   num = [0] * 26 #массив кол-ва букв алфавита

   for c in s:
      if c.isalpha():
         k = ord(c.upper()) - ord('A')
         num[k] += 1
   k = 1
   ic = 0
   for i in range(1,len(num)):
      if num[i] > num[ic]:
         ic = i
         k = 1
      elif num[i] == num[ic]:
         k += 1

   if k == 1:
      print (chr(ic + ord('A')))
   else:
      for i in range(0, len(num)):
         if num[i] == num[ic]:
            print(chr(i + ord('A')),end=" ")
         print()
   print(num[ic])

На вход программе подается последовательность символов, заканчивающаяся символом #. Другие символы # во входной последовательности отсутствуют.

Программа должна вывести на экран символы латинского алфавита, в порядке увеличения частоты встречаемости во входной последовательности.

Если буква во входной последовательности не встречается, её выводить не нужно.

Если несколько букв встречаются одинаковое количество раз, программа должна вывести их в алфавитном порядке.

Строчные и прописные буквы не различаются.

Напишите эффективную, в том числе и по используемой памяти, программу (укажите используемую версию языка программирования, например Borland Pascal 7.0), которая должна решать поставленную задачу.

Пример входных данных:
Aced, ccedaa f#
Пример выходных данных:
FDEAC

Решение:

Количество каждой буквы в строке

Для вывода букв, в порядке увеличения частоты встречаемости, нужен массив количества букв алфавита:

    s = "…" ;строка со словами и другими символами
    n = длина строки s
    num[26] ;массив количества латинских букв алфавита
    Для i от 1 до n ;по каждому символу строки s
        если s[i] буква то ;буква-не буква
            k = номер буквы
          ;увеличиваем счётчик количества таких букв
            num[k] = num[k] + 1
			

Сортировка

Отсортируем массив num по возрастанию:

    Для i от 1 до 25 ;от 'A' до 'Y'
        Для j от 25-i
            если num[j] > num[j+1] то
                t = num[j]
                num[j] = num[j+1]
                num[j+1] = t ;

Получили отсортированную по возрастанию, частоту встречаемости символов, но неизвестно какие это будут символы – индексы будут утеряны.

Выход такой: завести массив символов по алфавиту sym. Далее, одновременно с сортировкой массива num, будут перестановки элементов массива sym с теми же индексами, что и индексы массива num:

    …
    sym = [a,b,c,…,z]
    Для i от 1 до 25 ;от 'A' до 'Y'
        Для j от 25-i ;
            если num[j] > num[j+1] то
                t = num[j]              c = sym[y]
                num[j] = num[j+1]       sym[j] = sym[j+1]
                num[j+1] = t            sym[j+1] = c

Вывод результатов

Если дана строка Aced, ccedaa f , то после сортировки массивы num и sym будут такими:

num — [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 2 3 3]

sym — [b g h I j k l m n o p q r s t u v w x y z f d e a c]

Выводим символы массива sym, начиная с символа f:

    j = 22 ;индекс символа 'f'
    Для i от j до 26 ;от 22 до 26
        печать sym[i]

Найти значение первого символа легко: если посмотреть на массив num, то в нём 21 нуль:

    j = 0 ;индекс символа 'f'
    Пока num[j] = 0 ; после цикла j будет равно 22
        j = j + 1
    Для i от j до 26 ;от 22 до 26
        печать sym[i]

Полный код на Python

   s = "Aced, ccedaa f#" #символ '#' в этом коде не нужен
   num = [0] * 26 #массив кол-ва латинских букв алфавита
   sym = [0] * 26 #массив латинских букв алфавита ('a'.. 'z')

   for i in range(26):
      sym[i] = chr(i+65)

   for c in s:
      if c.isalpha():
         k = ord(c.upper()) - ord('A')
         num[k] += 1

   for i in range(26 - 1):
      for j in range(26 - i - 1):
         if num[j] > num[j + 1]:
            num[j], num[j + 1] = num[j + 1], num[j]
            sym[j], sym[j + 1] = sym[j + 1], sym[j]

   j=0
   while num[j] == 0:
      j += 1
   for i in range(j, 26):
      print(sym[i],end=" ")

Отчёты можно создавать на основании таблицы, таблиц, запроса и запросов.

Для этой практической работы, должна быть открыта база данных БД_Студенты4 сохранённая после предыдущей работы.

Отчёт 1

Создадим отчёт с помощью мастера, Создание/Очёты/Мастер отчётов:

На первом шаге диалога, в списке источника данных выбираем таблицу Студенты, внизу появятся все поля этой таблицы, кнопкой > перенесём поля: НомерСтудБилета, Фамилия, Имя, Отчество, Деятельность и Стипендия, жмём Далее, на втором шаге предлагается выбрать группировку(мы её разберём позже) по умолчанию ничего не предложено, жмём Далее, на третьем шаге предлагают задать сортировку записей, её лучше делать в режиме предварительного просмотра отчёта, также жмём Далее, на четвёртом шаге выбираем табличный макет, книжную ориентацию и активируем флажок настройки ширины полей, жмём Далее, на последнем шаге имя отчёта Студенты выбираем флажок Просмотреть отчёт и жмём Готово

Открылся отчёт в режиме предварительного просмотра. Внизу справа листа отчёта указана текущая страница и их общее количество. Внизу окна программы кнопки навигации по листам отчёта. Правый клик по вкладке отчёта, закроем его. Слева панель отобразила новый тип объекта базы данных – отчёт Студенты:

Отчёт 2

Создадим отчёт с помощью мастера, Создание/Очёты/Мастер отчётов:

На первом шаге диалога, в списке источника данных выбираем запрос Выбор факультета, внизу появятся все поля этой таблицы, кнопкой >> перенесём все поля, жмём Далее, на втором шаге по умолчанию предложена группировка по полю КодФакультета, это потому что поле КодФакультета есть внешний ключ и содержит повторяющиеся записи, поэтому программа предложила группировку именно по этому полю. Для нас это не важно просто, жмём Далее, на третьем шаге жмём Далее, на четвёртом шаге выбираем ступенчатый макет, альбомную ориентацию и активируем флажок настройки ширины полей, жмём Далее, на последнем шаге имя отчёта Выбор факультета выбираем флажок Просмотреть отчёт и жмём Готово

Поскольку отчёт строится по параметрическому запросу, то он будет требовать ввода значения для поля КодФакультета, введём 3 и ОК. В результате будет построен отчёт для студентов из 3-го факультета. Чтобы изменить внешний вид полей, нужно перейти в режим макета или конструктора. Перейдём в режим макета правым кликом по вкладке или командой Конструктор/Режимы далее в списке режимов выбрать режим макета:

Теперь выберем несколько полей и на вкладке Формат группа Форматирование элементов управления в списке Контур фигуры выберем любой цвет:

Перейдём в режим предварительного просмотра, чтобы проверить результат перед печатью. Правый клик по вкладке закроем отчёт.

Отчёт 3

Создадим отчёт с помощью мастера, Создание/Очёты/Мастер отчётов:

На первом шаге диалога, в списке источника данных выбираем таблицу Факультеты, кнопкой >> перенесём все поля, теперь выбираем таблицу Студенты и выбираем поля НомерСтудБилета, Фамилия, Имя, Отчество и Деятельность, жмём Далее, на втором шаге подобно формам слева окно с выбором главной таблицей, а справа результат полей таблиц на основании связи между таблицами. Выбираем главной таблицу Факультеты. Поскольку таблица Факультеты является главной, то справа расположение её полей будут выше относительно полей таблицы Студенты, жмём Далее, на третьем и четвёртом шаге жмём Далее, на пятом шаге выбираем блочный макет, альбомную ориентацию и активируем флажок настройки ширины полей, жмём Далее, на последнем шаге имя отчёта Факультеты выбираем флажок Просмотреть отчёт и жмём Готово

На предварительном просмотре под каждой записью главной таблицы Факультеты, расположены соответствующие записи вторичной таблицы Студенты. Сохраним и закроем отчёт.

Отчёт 4

Создадим отчёт с помощью мастера, Создание/Очёты/Мастер отчётов:

На первом шаге диалога, в списке источника данных выбираем запрос Экскурсии 2014, кнопкой >> перенесём все поля, жмём Далее, на втором шаге слева окно с выбором главной таблицей, а справа результат полей таблиц на основании связи между таблицами. Выбираем главной таблицу Экскурсии, жмём Далее, на третьем и четвёртом шаге жмём Далее, на пятом шаге выбираем ступенчатый макет, альбомную ориентацию и активируем флажок настройки ширины полей, жмём Далее, на последнем шаге имя отчёта Экскурсии 2014 выбираем флажок Просмотреть отчёт и жмём Готово

На предварительном просмотре под каждой записью главной таблицы Экскурсии, расположены соответствующие записи таблиц Студенты и Факультеты. Сохраним и закроем отчёт.

Отчёт 5

Создадим отчёт с помощью мастера, Создание/Очёты/Мастер отчётов:

На первом шаге диалога, в списке источника данных выбираем таблицу Студенты, внизу появятся все поля этой таблицы, кнопкой > перенесём поля: НомерСтудБилета, Фамилия, Имя, Отчество, Деятельность, Стипендия и КодФакультета, жмём Далее, на втором шаге предлагается выбрать группировку(вспомним что такое групповой запрос) поскольку мы выбрали связанное поле КодФакультета, то программа предлагает выбрать группировку. По умолчанию группировка по полю КодФакультета(если нужно изменить группировку, воспользуемся кнопками < и > для удаления и выбора полей соответственно), оставляем группировку по полю КодФакультета и жмём Далее, на третьем шаге предлагают задать сортировку записей, а также в связи с тем, что у нас выбрано групповое поле, появилась кнопка Итоги, жмём на неё, программа построила поля по которым можно применить групповые операции, выберем операцию Sum правее оставим флажок данные и итоги и Вычислить проценты жмём ОК и Далее, на четвёртом шаге выбираем ступенчатый макет, альбомную ориентацию и активируем флажок настройки ширины полей, жмём Далее, на последнем шаге имя отчёта Студенты по факультетам, выбираем флажок Просмотреть отчёт и жмём Готово

Открылся отчёт в режиме предварительного просмотра. Возможно данные поля Стипендия не уместились. Правый клик по вкладке отчёта и переходим в режим макета. Двигая и изменяя размер полей, освободим место для данных поля Стипендия.

Теперь проверим результат отчёта(можно и в режиме макета). Первый факультет содержит 4 студента, их общая сумма отображена напротив поля Sum. Непонятную строку С разделителями разрядов лучше изменить на Доля суммы факультета

Оформим внешний вид для полей и фона самостоятельно с помощью команд: Конструктор/Темы и Формат/Форматирование элементов управления/Заливка фигур или Контур фигур. Правый клик по вкладке закроем отчёт.

Откроем отчёт Студенты по факультетам и перейдём в режим макета. Проверим расположение одинаковых фамилий и имён в 3-м факультете.

Выполним команду Конструктор/Группировка и итоги/Группировка:

Внизу отчёт, отделился областью Группировка, сортировка и итоги и две кнопки Добавить группировку и Добавить сортировку. Выбрана группировка по полю КодФакультета:

Нажимаем Добавить сортировку в поле со списком выбираем пункт Фамилия. Повторим для пунктов Имя и Отчество:

Проверим сортировку одинаковых фамилий и имён в 3-м факультете.

Выделите зелёным цветом заливку, стипендий менее 800. (делаем по тому же принципу как мы делали в формах с помощью условного форматирования)

Аналогично для поля Сумма по факультету выделите фон жёлтым цветом для значений более 800 руб. Подсказка. Выделите поле с суммой и примените условное форматирование.

По умолчанию большие отчёты идут сплошными страницами и разорваны без учёта начала той или иной группы. Настроим разрывы в отчётах.

В режиме конструктора правый клик по заголовку группы КодФакультета, выбираем Свойства:

Появится панель Окно свойств на вкладке Макет свойство Конец страницы выбираем пункт До раздела:

Переключаемся в режим предварительного просмотра и пролистаем студентов по факультетам. Переключаемся в режим конструктора

Построить отчёт с расчётом средней стипендии по каждой деятельности.

Откроем файл базы данных БД_Студенты_4. Выбираем Включить содержимое. Вспомним, как создавать формы и создадим форму по всем полям студентов и назовём её Студенты

Откроем таблицу Студенты. Раскроем в заголовке поля Деятельность, список его свойств, снимем галочку Выделить всё и активируем галочку Музыкант:

Жмём ОК и таблица отобразит записи студентов музыкантов, а заголовок поля Деятельность, отобразит значок с фильтром. Кроме этого значка, режим фильтра виден на вкладке Главная в группе Сортировка и фильтр – выделена кнопка Фильтр:

Раскроем поле Деятельность, выберем галочку Выделить всё и жмём ОК.

Отобразим студентов которые помогают библиотеке , но другим способом: правый клик в ячейке Библиотекарь и выбираем Равно «Библиотекарь». Отменим эту операцию опять же правый клик в поле Библиотекарь и Снять фильтр с Деятельность:

Если бы мы отменили предыдущий фильтр активной кнопкой Фильтр из Главная/Сортировка и фильтр, то она бы снова отобразила всех кассиров.

Отобразим с помощью фильтра студентов, стипендия которых больше 800: правый клик по любой ячейке поля Стипендия, выбираем Числовые фильтры/Больше, в диалоге вводим 800 и ОК. Таблица отобразит записи студентов, стипендия которых больше чем 800. Снимем фильтр кнопкой Фильтр на Главная/Сортировка и фильтр.

Отобразим в этой таблице студенток со стипендиями до 800р и студентов со стипендиями: раскроем в заголовке поля Пол список, выберем галочку Женский и ОК. Затем раскроем в заголовке поля Стипендия список, выберем пункт Числовые фильтры/Меньше, в диалоге вводим 800 и ОК. Получили ????? строк. Теперь в этом же условии нужно ЕЩЁ отобразить мужчин, стипендия которых больше 800р: Не снимая предыдущего фильтра, выбираем команду Главная/Сортировка и фильтр/Дополнительно/Изменить фильтр (не перепутать кнопку Дополнительно, из группы Записи):

Появится бланк с нашим условием: Женский <= 800. Внизу две вкладки Найти и Или, активируем вкладку Или и вводим ещё одно условие в поле Пол – Мужской а в поле Стипендия — >=800.

Теперь отобразим результат кнопкой Фильтр на Главная/Сортировка и фильтр. Будут отображены строки согласно нашему сложному условию.

Снимем фильтр кнопкой Фильтр на вкладке Главная группа Сортировка и фильтр. Закроем таблицу Студенты.

Откроем форму Студенты, найдём всех IT-специалистов: правый клик по полю Деятельность (не заголовку) и выберем пункт Равно «IT-специалист» и теперь мы можем в форме пролистать только IT-специалистов.

Снимем фильтр кнопкой Фильтр на Главная/Сортировка и фильтр. Закроем форму.

Откроем таблицу Студенты. Отсортируем поле Деятельность по алфавиту: выделим за заголовок поле Деятельность и выполним команду Главная/Сортировка и фильтр/По возрастанию.

Отменим сортировку командой Главная/Сортировка и фильтр/Удалить сортировку.

Отсортируем по ФИО: выделим за заголовки одновременно три столбца Фамилия, Имя, Отчество и выполним команду Главная/Сортировка и фильтр/По возрастанию. Найдём однофамильцев и проверим результат сортировки их имён. Отменим сортировку пунктом Удалить сортировку на Главная/Сортировка и фильтр.

Однако отсортировать одновременно несмежные поля такой командой нельзя. Несмежные поля сортируются с помощью запросов.

Операция Итоги, помогают быстро получить некоторые вычисления. Для таблицы Студенты нажмём на вкладке Главная в группе Записи кнопку Итоги:

Внизу программы, появится строка Итог, щёлкнем в этой строке в ячейке поля Стипендия , появится раскрывающийся список:

Поскольку поле Стипендия содержит числовые данные, то в списке можно выбрать команды для получения суммы, среднего значения, количество записей, максимального и минимального значений в этом поле и другие команды. Проверим количество записей в этом поле:

Поскольку каждый студент содержит стипендию, то результат будет равен количеству записей таблицы(число записей показано внизу таблицы правее строки Запись, если отключить кнопку Итоги).

Теперь удалим две стипендии и проверим – итоговая ячейка отобразила минус два значения.

Также можно получить итоговый результат по отфильтрованному значению. Например, отобразим с помощью фильтра только студентов:

и проверим результат в итоговой ячейке. Снимем операцию Итоги, повторным нажатием на кнопку Итоги на вкладке Главная.

Найдём участников КВН: щёлкнем в любой ячейке поля Деятельность, далее Главная/Найти , заполним в диалоге поля:

Образец – Участник КВН, Поиск в — Текущее поле, Совпадение — С начала поля, Просмотр — Все. Последовательно нажимаем Найти далее до появления диалога с окончанием поиска.

Теперь поменяем всех музыкантов, участниками КВН: щёлкнем в любой ячейке поля Деятельность, далее команда Главная/Заменить заполним в диалоге поля

Образец – Музыкант, Заменить на – Участник КВН, Поиск — Текущее поле, Совпадение — С любой частью поля, Просмотр — Все. Нажимаем Заменить всё. Каждый музыкант, теперь будет только участником КВН. При этом отмена действий не возможна. Возможно только повторная замена КВНщиков на музыкантов, НО, если перед первой заменой КВНщики УЖЕ были, то после второй замены они получатся музыкантами.

Замена не сработает для поля, которое связано с первичной таблицей, а также, если поле с фиксированным набором значений, ограничено списком.

Аналогично можно произвести поиск в форме. Если открыть форму в режиме формы, щёлкнуть в поле с данными и выполнить команду Главная/Заменить.

Закроем все открытые объекты в базе данных.

Запросы служат для обработки табличной информации. Они производят отбор записей из одной или нескольких таблиц. Запросы могут сортировать несмежные поля таблиц, и производит вычисления для определённого вывода данных.

Запрос 1

В базе БД_Студенты_4, создадим запрос командой: Создание/Запросы/Конструктор запросов:

В конструкторе запроса появится диалог Добавление таблицы для выбора источника данных, откуда будем вести запрос. Выбираем таблицу Студенты, жмём Добавить и Закрыть:

В поле конструктора запросов появится панель с полями таблицы Студенты.

Удалим эту панель клавишей [Del], а затем снова добавим командой Конструктор/Настройка запроса/Отобразить таблицу:

Теперь двойной клик по полям в панели, добавим в запрос поля НомерСтудБилета, Фамилия, Имя, Деятельность и Стипендия:

Поля добавляются слева направо. Добавим в запрос поле Пол и удалим его для практики. Выделим в запросе поле Пол (чёрная стрелка над заголовком) и удалим клавишей [Del]:

Мы забыли поместить поле Отчество. Методом перетаскивания тянем из панели поле Отчество и располагаем в запросе поверх поля Деятельность:

И наконец, переместим поле Деятельность за полем Стипендия: Курсор над заголовком поля Деятельность так, чтобы курсор был в виде белой стрелки (если будет чёрная, двигаем немного вниз) затем располагаем курсор над правой границей поля Стипендия:

Запускаем запрос с отображением результата нашей работы: Конструктор/Результаты/Выполнить:

Получился результат как в таблице, но только с теми полями, которые мы отобразили. Возвращаемся обратно в режим конструктора правым кликом по вкладке и выбираем пункт Конструктор:

Упорядочим записи по возрастанию стипендии: в строке Сортировка нашего запроса, для поля Стипендия выбираем по возрастанию:

Запускаем запрос и проверяем, что все студенты отсортированы по окладу. Вернёмся в режим конструктора и уберём сортировку по окладу.

Двойным кликом добавим в запрос поле КодФакультета и аналогично отсортируем это поле по возрастанию:

запускаем запрос и проверяем, что поле КодФакультета отсортирован. Вернёмся в режим конструктора.

Теперь мы хотим, чтобы ФИО в каждом факультете тоже были отсортированы. Если мы добавим ещё сортировку по возрастанию для ФИО:

и запустим запрос, то в результате сортировка будет неправильной т.к. сортировка выполнилась слева направо. Проблема решается так:

1. добавляется ещё одно такое же поле в нашем случае это КодФакультета,
2. сортируется это поле
3. отключается видимость этого поля

Причём поле КодФакультета должно быть крайним левым в запросе:

Добавим в запрос, второе поле КодФакультета левее ФИО и применим ему сортировку по возрастанию, а сортировку для первого поля КодФакультета снимем. Запустим запрос. В результате появилось вымышленное имя для второго поля КодФакультета, поскольку два одинаковых поля в таблице быть не должно. Вернёмся в конструктор, и снимем галку Вывод на экран для левого поля КодФакультета :

и снова запустим запрос. В результате мы получили то, что хотели.

Правый клик по вкладке, сохраним запрос под именем Сортировка студентов по факультетам. Правый клик по вкладке, закроем запрос.

В левой панели программы MS Access, появился новый объект Запрос, если он не появился, выберите команду Все объекты Access:

Теперь дважды кликните по нему и программа запустит запрос.

Запрос 2

Создадим новый запрос в режиме конструктора:

В диалоге снова выбираем таблицу Студенты, жмём Добавить и Закрыть. Обратим внимание на звёздочку в панели с полями:

Сделаем двойной клик по этой звёздочке, мы получим в запросе всего одно поле (со звёздочкой):

Звёздочка заменяет отображение всех полей таблицы, если мы запустим запрос. Запустим запрос и увидим отображение всех полей таблицы. В чём удобство этого символа?

Если мы хотим вывести все поля таблицы, но при этом что бы выполнялось какое-то условие только для одного поля, мы добавим это поле в запрос и применим нужное для нас условие. Например, заставим запрос выводить все поля таблицы, но только для факультета 3: добавим в запрос поле КодФакультета, затем в строку Условие отбора введём 3:

Теперь запустим запрос. Появилась таблица, но с лишним полем для КодФакультета, вернёмся в конструктор, и отключим видимость для поля КодФакультета:

Снова запустим запрос для проверки изменений. Вернёмся в конструктор. Выделим оба поля и удалим их клавишей [Del]:

Добавим в конструктор запроса, поля Фамилия, Имя, Отчество, Деятельность и Стипендия. Отобразим студентов, у которых стипендия от 800 до 1000 включительно: Курсор в строку Условие отбора для поля Стипендия и вводим between 800 and 1000 (что бы лучше было видно текст, нажмём [Shift+F2])

ОК, запускаем запрос для проверки. Должно быть 19 записей.

Возвращаемся в конструктор, и отобразим студентов, у которых стипендия за пределами предыдущего диапазона, т.е. меньше 800 и больше 1000: изменим наше условие и добавим к нему логическое отрицание – Not:

Not between 800 and 1000

Запускаем запрос для проверки. Должно быть 16 записей.

Диапазоны

Вместо оператора between можно воспользоваться операторами сравнений, >,<, так, вместо between 800 and 1000 можно ввести

>= 800 and <= 1000

Но вместо Not between 800 and 1000 мы вводим

<800 or >1000

Самостоятельная работа

Отобразить студентов рождённых в 80-90 г.р включительно, т.е. между началом 1980 и концом 1979 года. И сохранить запрос под именем Студенты 80-90 года рождения.

Запрос 3

Создадим новый запрос в режиме конструктора:

В диалоге снова выбираем таблицу Студенты, жмём Добавить и Закрыть. Добавим в запрос поля НомерСтудБилета, Фамилия, Имя, Отчество, Деятельность и Стипендия. Отобразим всех пешеходов: в строке Условие отбора поля Деятельность вводим лаборант, нажимаем [Tab] или щёлкнем в любом месте запроса. Запустим запрос, для проверки работы условия.

Аналогично отобразим всех волонтёров (в этом же запросе), но поскольку слева и справа в названии этой деятельности добавлено ещё и пояснение, то в условии требуется добавить управляемые символы *: введём в строку Условие отбора — *волонтёр*. Программа подставит Like и поместит условие в кавычки:

Запустим запрос для проверки. Должно быть 6 записей. Правый клик по вкладке, сохраним запрос под именем Волонтёры и закроем его.

Запрос 4

Создадим новый запрос в режиме конструктора:

В диалоге снова выбираем таблицу Студенты, жмём Добавить и Закрыть. Добавим в запрос поля Фамилия, Имя, Отчество, и Хобби. Запустим его и убедимся, что в поле Хобби, есть данные и пустые ячейки. Отобразим всех, у кого НЕТ хобби: в режиме запроса в строку Условие отбора для поля Хобби вводим null, запустим запрос и проверяем всех, у кого нет хобби. Аналогично отобразим всех, у кого есть хобби: в режиме конструктора туда же вводим not null и запустим запрос для проверки.

Вернёмся в конструктор, и введём предыдущие два условия в альтернативной форме: not* — результат тот же, что и при null и * — тоже что и not null. Правый клик по вкладке, сохраним запрос под именем Нет хобби. Закроем запрос.

Запрос 5

Создадим новый запрос в режиме конструктора:

В диалоге снова выбираем таблицу Студенты, жмём Добавить и Закрыть. Добавим в запрос поля Фамилия, Имя, Отчество, Деятельность и ГражданствоРФ. Запустим его и убедимся, что в поле ГражданствоРФ установлены флажки, т.е. это логический тип, а условия для логических типов содержат либо 1(Истина), либо 0(Ложь).

В режиме конструктора в условие отбора для поля ГражданствоРФ, введём 0, запустим запрос и проверим, должно быть 6 записей, а в поле ГражданствоРФ флажки пустые. Сохраним запрос под именем Нет гражданства

Самостоятельная работа

Создать новый запрос, который отображает студентов, у которых код телефона либо 903, либо 910.

Подсказка. Использовать два условия одно в строке Условие отбора, другое в строке или. Сохранить запрос под именем Моб. телефон 903 910 и закрыть его.

Запрос 6

Создадим новый запрос в режиме конструктора:

Двойной клик, и выбираем таблицы Студенты, Факультеты, Экскурсии и жмём Закрыть:

Таблицы Студенты и Факультеты связаны, но таблицу, с которой связана таблица Экскурсии, мы не отобразили. Какой может быть результат, если отобразить поля несвязанных таблиц? Поместим в запрос поля Фамилия, Имя, Отчество и Название:

Запустим запрос. Результат будет неожиданный: 175 записей. Т.е. каждая запись! таблицы Экскурсии, содержит все записи несвязанной с ней таблицей.

Вернёмся в конструктор и добавим таблицу, которая связана с таблицей Экскурсии и с таблицей Студенты: правый клик по пустому полю с панелями, пункт Добавить таблицу, в диалоге добавим таблицу Экскурсанты и жмём Закрыть:

Другими словами, при связи МНОГИЕ-КО-МНОГИМ ( ∞ : ∞ ), должны быть добавлены все три таблицы, а формировать запрос с несвязанными таблицами нельзя!!!

Удалим все поля в запросе. Теперь отобразим студентов из определённого факультета, которые посетили ту или иную экскурсию: из таблицы Студенты выбираем НомерСтудБилета и ФИО. Из таблицы Факультеты берём поле Факультет. Из таблицы Экскурсии берём поля Название и ДатаЭкскурсии. Запускаем, проверяем и возвращаемся в конструктор.

Теперь отобразим все экскурсии в 2014 году: в условии отбора поля ДатаЭкскурсии, введём *2014, запустим и проверим результат. Сохраним запрос под именем Экскурсии 2014 и закроем его.

Самостоятельная работа

Создать новый запрос, который отображает студентов (НомерСтудБилета, ФИО), которые сдали сертификацию(Название) в 2013-2014 г.г. Запрос сохраните под именем Сертификация 2013-2014

Вычисляемые поля

Запрос 7 (Посчитаем бонус по формуле 41,3% от стипендии)

Создадим новый запрос в режиме конструктора:

В диалоге выбираем одну таблицу Студенты, жмём Добавить и Закрыть. Добавим в запрос поля: НомерСтудБилета, ФИО и Стипендия. Установим курсор правее поля Стипендия в ячейку Поле:

Откроем построитель выражений (Есть 3 способа) 1-й: Конструктор/Настройка запросов/Построитель:

2-й: Правый клик там где курсор и выбираем Построить:

3-й: жмём [Ctrl+F2], там где курсор

В верхнем поле диалога Построитель выражений пишем: Бонус:(двоеточие обязательно), в левом нижнем окне раскрываем: БД_Студенты_4/Таблицы/Студенты, в среднем окне двойной клик по полю Стипендия:

В верхнем окне диалога, строка «Выражение» нам не нужна, поэтому щёлкнем по ней и удалим, в результате имеем:

Бонус: [Студенты]![Стипендия]

Теперь вычислим процент от стипендии: в верхнем окне щёлкнем правее строки и умножим на 0,413:

Бонус: [Студенты]![Стипендия]*0,413

Нажимаем ОК(обратим внимание на галочку видимости в вычисляемом поле) и запускаем запрос для анализа результата. Вернёмся в конструктор.

Свойства вычисляемого поля

Поскольку вычисляемое поле не является табличным, значит настроить его формат, можно в конструкторе запроса: правый клик по названию поля и выбираем пункт Свойства. Появится панель Окно свойств. В свойстве Формат поля выберем денежный формат:

Сохраним запрос под именем Расчёт итогов, но не закрываем его.

Запрос 8(Посчитаем налог(13%) от стипендии + бонуса)

В режиме конструктора правее поля Бонус, щёлкнем, чтобы создать ещё одно вычисляемое поле и откроем построитель выражений комбинацией [Ctrl+F2]:

В верхнее окно пишем Налог:, а в левом нижнем окне, в отличии от предыдущего запроса, выделяем имя нашего запроса(оно есть, потому что мы его сохранили) и в среднем окне, двойной клик по полю Стипендия:

Строка «Выражение» нам не нужна, поэтому щёлкнем по ней и удалим.

Поскольку поле Бонус вычисляемое(т.е. не табличное), то его НЕЛЬЗЯ использовать в вычислениях, например, вот так:

[Бонус]*0,13

Мы должны снова вычислить бонус, затем вычислить процент от стипендия + процент от вычисленного бонуса:

[Стипендия] * (1+0,413) * 0,13

Откуда эта формула?

Если помнить, что 3 + 3 * 2 = 3(1+2), тогда:

([Стипендия]*0,413) *0,13+([Стипендия]*0,13) =

([Стипендия]*0,13) *0,413+([Стипендия]*0,13) =

[Стипендия] * 0,13 * (0,413+1)

Запускаем запрос для проверки. Вернёмся в конструктор.

Запрос 9(Посчитаем итоговую сумму, которую получит студент, т.е. стипендия + бонус без 13%)

В режиме конструктора правее поля Налог, щёлкнем, чтобы создать ещё одно вычисляемое поле и откроем построитель выражений комбинацией [Ctrl+F2]. В верхнее поле пишем СуммаРУБ:, в левом нижнем поле, выделяем имя нашего запроса и в среднем поле, двойной клик по полю Стипендия:

Строка «Выражение» в верхнем окне нам также не нужна, поэтому щёлкнем по ней и удалим.

Мы должны снова вычислить премию, затем вычислить (100%-13%) процентов от оклада и вновь вычисленной премии:

[Стипендия] *(1+0,413)*0,87

Самостоятельная работа

Посчитайте сумму с предыдущего запроса в долларах и в евро. Т.е. добавьте ещё два вычисляемого поля. Подсказка: используйте формулу из предыдущего запроса. Сохраните и закройте запрос Расчёт итогов.

Запрос 10(Объединение текстовых полей)

Пусть есть таблица Фрукты и требуется объединить два поля Яблоки и Груши. Формула для построителя будет такой:

[Фрукты]![Яблоки]&[Фрукты]![Груши]

Результат этого объединения: ЯблокиГруши<>

То же самое объединение, только с пробелом:

[Фрукты]![Яблоки]&» «&[Фрукты]![Груши]

Результат этого объединения: Яблоки Груши

Объединим поля Фамилия, Имя и Отчество с помощью вычисляемого поля: создадим новый запрос в режиме конструктора:

В диалоге выбираем одну таблицу Студенты, жмём Добавить и Закрыть.

Курсор в строку Поле и вызываем построитель выражений [Ctrl+F2]. В верхнем окне вводим имя вычисляемого поля ФИО:

В нижнем левом окне в нашей базе данных выделяем таблицу Студенты. В среднем окне двойной клик по полю Фамилия, в верхнем окне, выделяем строку «Выражение», удаляем её. После фамилии вводим &» «& (два амперсанда, внутри две английские кавычки, внутри пробел). В верхнее окно добавим поле Имя, и аналогично соединим с полем Отчество. Итоговый вид выражения:

ФИО: [Студенты]![Фамилия] & » » & [Студенты]![Имя] & » » & [Студенты]![Отчество]

Запустим запрос и проверим, что имя поля ФИО и каждая ячейка поля содержит три слова. Теперь вычислим возраст студентов по формуле сегодняшняя дата минус дата рождения:

В конструкторе добавим ещё одно вычисляемое поле. В построителе выражений в верхнем окне вводим Возраст:. В левом нижнем окне выделяем пункт Общие выражения, в среднем окне выделяем пункт Текущая дата и двойной клик по Date() в правом окне:

Строка «Выражение» в верхнем окне нам также не нужна, поэтому щёлкнем по ней и удалим.

Отнимаем дату рождения: добавляем в выражение минус и в таблице Студенты, двойной клик по полю Дата рождения.

ОК и запускаем запрос для проверки результата. Мы получили возраст в днях. Самостоятельно переведём дни в годы. Сохраним запрос под именем Возраст студентов и закроем его.

Параметрический запрос

Запрос 11 (Вывод студентов из конкретного факультета)

Создадим новый запрос в режиме конструктора:

В диалоге выбираем одну таблицу Студенты, жмём Добавить и Закрыть. Добавим в запрос поля: НомерСтудБилета, ФИО и КодФакультета

Параметрический запрос позволяет пользователю, во время запуска запроса, выбрать условие отбора и затем выполнить запрос. Т.е. здесь идёт автоматическая подстановка значения в поле Условие отбора.

Добавим для поля КодФакультета, в строку условие текст [Код факультета?]. Теперь запустим запрос. Появится диалог с предложением ввести значение, мы выбираем, только то значение, которое может быть в поле КодФакультета таблицы Студенты. Введём любую цифру от 1 до 4 и нажмём ОК.

Сохраним запрос под именем Выбор факультета, закроем его, а теперь запустим его двойным кликом из панели объектов слева, введём другую цифру и ОК.

Запрос с группировкой

Запрос 12 (Посчитаем по факультету, сумму стипендий, среднее значение от стипендии, минимальную стипендию и сколько студентов на факультете)

Создадим новый запрос в режиме конструктора:

В диалоге выбираем одну таблицу Студенты, жмём Добавить и Закрыть. Нужно добавить ещё одну таблицу, но мы уже закрыли диалог с таблицами, тогда отобразим снова диалог с таблицами командой Конструктор/Настройка запроса/Отобразить таблицу:

В диалоге добавляем таблицу Факультеты, жмём Добавить и Закрыть.

Добавим в запрос поле: Факультет, теперь выполним команду Конструктор/Показать или скрыть/Итоги:

В запросе для поля Факультет, появилась новая строка Групповая операция с операцией Группировка. Добавим в запрос четыре поля Стипендия, с групповыми операциями Sum, Avg, Min и Count для суммы, среднего значения, минимального и количества.

Итак, мы выбрали одно поле, по которому будет проходить ГРУППИРОВКА, и поля, по которым будут проходить ГРУППОВЫЕ ОПЕРАЦИИ.

Запускаем запрос и видим результат работы групповых операций по каждому из ??? факультетов. Единственный минус, это неудобные имена четырёх полей с группировкой. Исправим САМОСТОЯТЕЛЬНО имена четырёх полей на Сумма, Средняя стипендия, Минимальная стипендия и Кол-во студентов: в конструкторе с помощью панели Окно свойств и свойства Подпись. Запустим запрос и проверим имена новых полей.

Сохраним запрос под именем Расчёт по факультетам.

Самостоятельная работа

1. Посчитайте по деятельности, сколько студентов и средняя стипендия по деятельности.
2. Создать запрос для определения количества посетителей каждой экскурсий.
3. Рассчитать длительность экскурсии и стоимость одного дня экскурсии

запрос 1 — выполняется через групповые операции

запрос 2 — выполняется через групповые операции

запрос 3 — выполняется через вычисляемое поле

]]>