Member 13875519 Ответов: 3

Пожалуйста, помогите мне с этим кодом и расскажите мне о проблеме.


Микро приобрести массив a из N целых чисел. Поиграв в нее некоторое время, он устал от нее и решил обновить значение ее элемента. За одну секунду он может увеличить значение каждого элемента массива на 1. Он хочет, чтобы значение каждого элемента массива стало больше или равно К. Пожалуйста, помогите микро узнать минимальное количество времени, которое ему потребуется для этого.

Ввод:
Первая строка состоит из одного целого числа t, обозначающего количество тестовых случаев.
Первая строка каждого теста состоит из двух целых чисел, разделенных пробелами, обозначающих N и K.
Вторая строка каждого теста состоит из N целых чисел, разделенных пробелами, обозначающих массив A.

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

Что я уже пробовал:

#include <iostream>

using namespace std;

int add(int a[], int n, int k)
{    
    int count=0;
    int p;
    for(int i=0; i<n; i++)
        {
            a[i]=a[i]+1;
            count++;
        }
      p=min(a, n);
    if(p>=k)
    {
        return count;
    }
    else
    {
        add(a, n, k);
    }
    
}
int min(int a[], int n)
{
    int m=1000;
    for(int i=0;i<n; i++)
    {
        if(a[i]<m)
        {
        m=a[i];
        }
    }
    return m;
}
int main() {
    int t;
    cin>>t;
    while(t--){
        int n,k;
    
        int ans;
        cin>>n;
        cin>>k;
        int a[n];
        for(int i=0; i<n; i++)
        {
            cin>>a[i];
        }
    ans= add(a, n, k);
    cout<<ans<<"\n";
}
return 0;
}

KarstenK

добавьте некоторые выходные данные пользователя и отладочные сообщения. Чем использовать отладчик.

3 Ответов

Рейтинг:
25

Kornfeld Eliyahu Peter

Единственная проблема, которую я могу обнаружить - и вы тоже можете, читая ошибки компилятора - это порядок функций...
add звонки min, но в этот момент min еще не определено...
Немедленное решение состоит в том, чтобы двигаться min вверх, до того, как add...
Для долгосрочной перспективы прочтите это: Функции - Учебники По C++ [^]


Member 13875519

Спасибо @Kornfeld, теперь мой код успешно скомпилирован, но есть проблема с моей логикой, вы можете мне в этом помочь?

Kornfeld Eliyahu Peter

Нет. Насколько я могу видеть (взял ваш код в компилятор GNU C++), код не компилируется...
Однако, чтобы помочь с логическим оформлением, вы должны дать нам больше подсказок: что такое вход? Каков ожидаемый результат? Каков реальный результат? Вы использовали свой отладчик?

Member 13875519

Sample input     Sample expected output              Real Output
2                 3                                  3
3 4               0                                  3
1 2 5
3 2
2 5 5

Kornfeld Eliyahu Peter

Непонятный... У вас есть 3 ожидаемых входных значения (t, n и k), но в таблице выше я их не вижу...

Member 13875519

прочтите вопрос, опубликованный выше ...вы поймете, как расположены входные данные

Kornfeld Eliyahu Peter

T = 2
N = 3 K = 4
A[N] = 1 2 5		Expexted: 3	Real: 3
N = 3 K = 2
A[N] = 2 5 5		Expected: 0	Real: 3

Kornfeld Eliyahu Peter

Я пытался следовать твоей логике, но запутался в ней...
Вот мой подход:
1. Найдите наименьшее значение в A (по определению это будет число секунд)
2. Если найденное значение меньше, чем K в чем разница ответ, иначе ответ 0

Рейтинг:
1

OriginalGriff

Как вы ожидаете, что мы "расскажем вам о проблеме"? Мы понятия не имеем, какие данные вы ему предоставили, какие результаты вы получили, или какие ценности вы ожидали.

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

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

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

Input   Expected output    Actual output
  1            2                 1
  2            4                 4
  3            6                 9
  4            8                16
Тогда совершенно очевидно, что проблема заключается в бите, который удваивает его - он не прибавляет себя к себе или умножает его на 2, он умножает его на себя и возвращает квадрат входного сигнала.
Таким образом, вы можете посмотреть на код, и очевидно, что он находится где-то здесь:
int Double(int value)
   {
   return value * value;
   }

Как только у вас появится идея, что может пойти не так, начните использовать отладчик, чтобы выяснить, почему. Поместите точку останова в первую строку функции и запустите приложение. Когда он достигнет точки останова, отладчик остановится и передаст управление вам. Теперь вы можете запускать свой код построчно (так называемый "одноступенчатый") и просматривать (или даже изменять) содержимое переменных по мере необходимости (черт возьми, вы даже можете изменить код и повторить попытку, если вам это нужно).
Подумайте о том, что должна делать каждая строка кода перед ее выполнением, и сравните это с тем, что она действительно делала, когда вы использовали кнопку "Step over" для выполнения каждой строки по очереди. Он сделал то, что вы ожидали? Если да, то переходите к следующей строке.
Если нет, то почему? Чем это отличается?
Надеюсь, это поможет вам определить, в какой части этого кода есть проблема и в чем она заключается.
Это навык, и его стоит развивать, поскольку он помогает вам как в реальном мире, так и в развитии. И, как и все навыки, он только улучшается при использовании!


Рейтинг:
1

Mike V Baker

Вы получили несколько советов о том, как быть более конкретным в ваших вопросах, так что я не буду тратить на это время. Что я хотел бы проверить, так это логику вашего решения. У микро есть массив, и он хочет увеличить значение каждого элемента до тех пор, пока этот элемент не станет >= k, и это займет одну секунду для каждого приращения. Таким образом, ответ на количество времени для каждого элемента составляет k - a[i] секунд. Вам не нужно на самом деле увеличивать элемент и отслеживать количество. Вы просто должны вернуться, сколько времени это займет.
Возможно, я неправильно понял вопрос. Он говорит, что за 1 секунду он может увеличить значение каждого элемента массива. Он не говорит, что он должен увеличить все элементы на равное количество.
Следующее, что меня интересует, - это почему функция add вызывает функцию add рекурсивно? Если p < k, то ему не нужно начинать все сначала с a, n и k, ему просто нужно продолжать считать секунды, пока он не дойдет до конца массива и не вернет общее количество секунд.

int sec = 0;
for (int i=0; i<n; i++)
{
    if (a[i] < k) {
        sec += k - a[i];
    }
}
return sec;
сек - это количество секунд, которое потребуется, чтобы убедиться, что каждый элемент равен по крайней мере = k.

Допустим, я ошибаюсь в своей интерпретации, и вы должны увеличивать каждое значение на равную величину. В этом случае это будет время, необходимое для увеличения наименьшего элемента до K раз числа элементов в массиве. Ваша функция 'min' потерпит неудачу для массива, все значения которого равны > 1000. Я не могу вспомнить, какие константы доступны на этом низком уровне-доступен ли MAXINT? Чтобы сделать его абсолютно 100% пуленепробиваемым, вам нужно начать с такого числа, чтобы оно максимально соответствовало объему хранилища. Остальная логика там кажется прекрасной. Расчет будет следующим
k - min(a, n) * n;
Это будет то, сколько секунд потребуется, чтобы увеличить все элементы таким образом, чтобы наименьший из них был по крайней мере == k.

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

Майк

[обновление] подумал о недостатке в моей логике. Если какие - либо элементы являются > k, то значение " sec " будет уменьшено, потому что k-a[i] приведет к отрицательному значению. Добавлена проверка "если".