Exit outside the range



  • function IntToArr(a: integer): array of integer; //функция перевода числа в массив цифр
    begin
        a := Abs(a);
        var i: integer := 1;
        SetLength(Result, i);
        while a >= 10 do //считывание цифр по разрядам от меньшего (до предпоследнего)
        begin
            Result[i - 1] := a mod 10; //цифра в текущем разряде
            a := a div 10; //перевод в следующий разряд
            i += 1;
            SetLength(Result, i); //увеличение длины массива
        end;
        Result[i - 1] := a; //цифра наивысшего разряда
        Reverse(Result); //упорядочивание по порядку числа
    end;
    
    function IntDiv(a: integer): integer; //функция для подсчёта разрядов в числе
    begin
        Result := 0;
        while a <> 0 do
        begin
            a := a div 10;
            Result += 1;
        end;
    end;
    
    var
        a, b, i, nmax, nmin: integer;
        num: array of integer;
    
    begin //программа для нахождения наименьшей и наибольшей цифры в числе
        Readln(a);
        num := IntToArr(a);
        writeln(num);
        b := IntDiv(a); //разбираем на массив
        writeln('Кол-во разрядов: ', b);
        nmin := num[1]; //устанавливаем первый элемент
        for i := 1 to b do
        begin
            if num[i] < nmin then nmin := num[i]; //нахождение наименьшего значения (ошибка выхода за пределы массива)
        end;
        writeln('Наименьшая цифра: ', nmin);
        nmax := num[1]; //устанавливаем первый элемент
        for i := 1 to b do
        begin
            if num[i] > nmax then nmin := num[i]; //нахождение наибольшего значения (ошибка выхода за пределы массива)
        end;
        writeln('Наибольшая цифра: ', nmax);
    end.
    

    I can't understand what this is about, the program will come together, when choosing the smallest and most dynamic body, it goes beyond the range, although it should not. Why is this happening and how to fix it?



  • http://docwiki.embarcadero.com/RADStudio/Seattle/en/Structured_Types#Dynamic_Arrays You can see the clarification.

    Once a dynamic array has been allocated, you can pass it to the standard functions Length, High, and Low. Length returns the number of elements in the array, High returns the array's highest index (that is, Length - 1), and Low returns 0. In the case of a zero-length array, High returns -1 (with the anomalous consequence that High RO Low).


    After the dynamics were released, you can transfer it to standard functions. LengthHighLowLength reset the number of elements in the mass, High returns the maximum mass index (i.e. Length - 1), and Low - 0. In the case of a zero length, High return -1 (with an anomalies that the maximum index is less than the minimum).

    So you can rectify the cycle and leave the rigid constants.

    nmin := num[Low(num)]; //устанавливаем первый элемент
    

    and cycle

    for i := Low(num) to High(num) do
    

    Similarly, it can be seen from the background that dynamic masses have indexes from 0 before Length-1
    While you're trying to treat them. 1 before b - which is equal. Length♪ So another option would be to shift the index to one.

    nmax := num[0];
    

    and within the cycle

    if num[i-1] < nmin then nmin := num[i-1];
    

    or cycle determination

    for i := 0 to b-1 do
    



Suggested Topics

  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2
  • 2