Данная программа ищет самый популярный фильм среди данных

#include <stdio.h>
#include <string.h>

typedef struct
{
char name[1000];
int reme;
} filmq;

int main()
{
filmq film[1000];
char str[1000];
int max_num[3]= {0},max[3]= {0},i,n,cur_num=0;
scanf("%d",&n);
for(i=0; i<n; i++)
{
int j;
scanf("%s",str);
for(j=0; j<cur_num; j++)
{
if(strcmp(str,film[j].name)==0)
{
film[j].reme++;
break;
}
}
if(j==cur_num)
{
strcpy(film[cur_num].name,str);
film[cur_num].reme=1;
cur_num++;
}
}
int j;
for(j=0; j<cur_num; j++)
{
if(film[j].reme>max[0] || (film[j].reme==max[0] && strcmp(film[j].name,film[max_num[0]].name)<0))
{
max_num[2]=max_num[1];
max_num[1]=max_num[0];
max_num[0]=j;
max[2]=max[1];
max[1]=max[0];
max[0]=film[j].reme;
}
else if(film[j].reme>max[1] || (film[j].reme==max[1] && strcmp(film[j].name,film[max_num[1]].name)<0))
{
max_num[2]=max_num[1];
max_num[1]=j;
max[2]=max[1];
max[1]=film[j].reme;

}
else if(film[j].reme>max[2] || (film[j].reme==max[2] && strcmp(film[j].name,film[max_num[2]].name)<0))
{
max_num[2]=j;
max[2]=film[j].reme;
}
}
for(j=0;j<3;j++)
{
printf("1. %s %d\n",film[max_num[j]].name,max[j]);
}
return 0;
}

Функции в Python

Функции в Python создаются с помощью инструкции def. Это действие создает объект функции и присваивает ему имя, которое становится ссылкой на объект-функцию.

Пример определения функции:

def MyFirstFunction(arg1, arg2, arg3):
return arg1 + arg2 + arg3

Здесь MyFirstFunction — это имя функции, используемое как для ее определения, так и для ее вызова.

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

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

ВЫЗОВ ФУНКЦИИ И ВОЗВРАТ ЗНАЧЕНИЯ

Пример вызова функции:

x = MyFirstFunction(10, 2, 5)
В данном случае, если бы в функции не было инструкции return, то в основную программу ничего бы не возвращалось, и переменной x числовое значение не присваивалось бы. Если функция не возвращает значение явно с помощью команды return, то автоматически возвращается значение None.

ПЕРЕДАЧА ПАРАМЕТРОВ В ФУНКЦИЮ

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

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

ПРИМЕРЫ

Допустим, необходимо вычислить число сочетаний из n элементов по k, равное n!/(k!(n−k)!), для чего необходимо вычисление факториалов трех величин: n, k и n-k. Для этого можно сделать три цикла, что приводит к увеличению размера программы за счет трехкратного повторения похожего кода. Вместо этого лучше сделать одну функцию, вычисляющую факториал любого данного числа n и трижды использовать эту функцию в своей программе. Соответствующая функция может выглядеть так:

def factorial(n):

result = 1

for i in range(2, n + 1):

result *= i

return result

Этот код должен идти до того места, где мы захотим воспользоваться функцией factorial.

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

Далее идет тело функции, оформленное в виде блока, то есть с отступом. Внутри функции вычисляется значение факториала числа n и оно сохраняется в переменной result. Функция завершается инструкцией
return result
которая завершает работу функции и возвращает значение переменной result. Инструкция return может встречаться в произвольном месте функции, ее исполнение завершает работу функции и возвращает указанное значение в место вызова. Если функция не возвращает значения, то инструкция return используется без возвращаемого значения, также в функциях, не возвращающих значения, инструкция return может отсутствовать.

Теперь мы можем использовать нашу функцию несколько раз. В этом примере мы трижды вызываем функцию factorial для вычисления трех факториалов: factorial(n), factorial(k), factorial(n-k).

n = int(input())

k = int(input())

print(factorial(n) // (factorial(k) * factorial(n - k)))

Мы также можем, например, объявить функцию binomial, которая принимает два целочисленных параметра n и k и вычисляет число сочетаний из n по k:

def binomial(n, k):

return factorial(n) // (factorial(k) * factorial(n - k))

Тогда в нашей основной программе мы можем вызвать функцию binomial для нахождения числа сочетаний:

print(binomial(n, k))

Вернемся к задаче нахождения наибольшего из двух или трех чисел. Функцию нахождения максимума из двух чисел можно написать так (впрочем, в Python есть и встроенная функция max):

def max(a, b):
if a > b:
return a

else:

return b

Теперь мы можем реализовать функцию max3, находящую максимум трех чисел:

def max3(a, b, c):

return max(max(a, b), c)

Функция max3 дважды вызывает функцию max для двух чисел: сначала, чтобы найти максимум из a и b, потом чтобы найти максимум из этой величины и c.

Граф вызовов функций

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

Заметим, что он может быть составлен не только для функций, но и для процедур, то есть для любых подпрограмм. В языках Си и Python процедуры синтаксически не отличаются от функций и даже не выделяются в отдельное понятие. Т.е. все подпрограммы — функции, только некоторые могут ничего не возвращать.

По данному графу видно, что функция A непосредственно вызывает функцию B, которая, в свою очередь, вызывает функцию C(), а та пользуется функцией D().

После вызова функцией А функции B, она сама погружается в ожидание завершения подпрограммы.

Таким образом, функции A() важен результат B(), и она не может без него продолжить свое выполнение.

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

ПРИМЕР НА ЯЗЫКЕ СИ

//заголовки функций:
int A();
int B();
int C();
int D();

//тела функций
int A()
{
printf("A() started\n");
int result = B() + 1;
printf("A() finished\n");
return result;
}

int B()
{
printf("B() started\n");
int result = C() + 1;
printf("B() finished\n");
return result;
}

int C()
{
printf("C() started\n");
int result = D() + 1;
printf("C() finished\n");
return result;
}

int D()
{
printf("D() started\n");
int result = 1; //никого не вызывает - это последняя по глубине вызовов функция
printf("D() finished\n");
return result;
}