Не­об­хо­ди­мо со­здать мас­сив из 10 эле­мен­тов с ин­дек­са­ми от 0 до 9 и ис­поль­зо­вать его для подсчёта ко­ли­че­ства всех цифр. Ис­поль­зо­ва­ние мас­си­ва не де­ла­ет про­грам­му не­эф­фек­тив­ной по па­мя­ти, так как раз­мер мас­си­ва не за­ви­сит от N. Затем нужно найти зна­че­ние мак­си­маль­но­го эле­мен­та этого мас­си­ва и вы­ве­сти в по­ряд­ке убы­ва­ния ин­дек­сы всех эле­мен­тов, рав­ных этому мак­си­му­му.

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

Ниже при­ве­де­на ре­а­ли­зу­ю­щая опи­сан­ный выше ал­го­ритм про­грам­ма на языке Пас­каль (ис­поль­зо­ва­на вер­сия PascalABC)

var
    N: integer; {ко­ли­че­ство чисел}
    a: integer; {оче­ред­ное число}
    digit: integer; {цифра числа}
    d: array [0..9] of integer; {подсчёт цифр}
    mx: integer; {мак­си­маль­ное ко­ли­че­ство цифр}
    i: integer;
begin
    for i:=0 to 9 do d[i]:=0;
    readln(N);
    for i:=1 to N do begin
        readln(a);
        while a>0 do begin
                digit := a mod 10;
                d[digit] := d[digit]+1;
                a := a div 10;
        end;
    end;
    mx := 0;
    for i:=0 to 9 do begin
        if d[i] > mx then mx := d[i];
    end;
    for i:=9 downto 0 do begin
        if d[i]=mx then write(i, ' ');
    end;
end.

При­мер пра­виль­ной, но не­эф­фек­тив­ной про­грам­мы на языке Пас­каль.

var
    N: integer; {ко­ли­че­ство чисел}
    a: array [1..1000] of integer; {ис­ход­ные дан­ные}
    digit: integer; {ко­ли­че­ство всех цифер ис­ход­ных чисел}
    d: array [1..4000] of integer; {подсчёт цифр}
    max_lenght: integer;
    i, j, k, lenght: integer;
begin
    readln(N);
    digit := 1;
    for i := 1 to 4000 do d[i]:=0;
    for i:= 1 to N do read(a[i]);
    for i := 1 to N do
      while a[i]<>0 do begin
        d[digit] := a[i] mod 10;
        digit := digit+1;
        a[i] := a[i] div 10;
      end;
    for i :=1 to digit-1 do
      for j:= 1 to digit-1-i do
        if d[j]          k := d[j];
          d[j] := d[j+1];
          d[j+1] := k;
        end;
    max_lenght := 0;
    lenght := 1;
    for i := 1 to digit-1 do
      if d[i]=d[i+1] then
        lenght := lenght + 1
      else begin
      if lenght>max_lenght then begin
      max_lenght := lenght;
      end;
      lenght := 1;
      end;
    lenght := 1;
    for i := 1 to digit-1 do
      if d[i]=d[i+1] then
        lenght := lenght + 1
      else begin
        if lenght=max_lenght then write(d[i], ' ');
        lenght := 1;
      end;
end.

При­во­дим эф­фек­тив­ное ре­ше­ние Игоря Ку­да­ше­ва на Python 3.