Почему возвращается false до того, как переменная запуска будет равна значению запуска в Ruby? Практически увеличивающаяся последовательность кодовых боев

Question

Одним из инструментов, которые я использую для улучшения кодирования, является Codefights. Я застрял на той же проблеме в течение нескольких дней и мог бы помочь мне разобраться. Может кто-нибудь сказать мне, что я здесь делаю не так?

Вот инструкции от CodeFights:

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

пример

Для sequence = [1, 3, 2, 1] выходные данные должны быть почти IncreasingSequence(sequence) = false;

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

Для sequence = [1, 3, 2] выходные данные должны быть почти IncreasingSequence(sequence) = true.

Вы можете удалить 3 из массива, чтобы получить строго возрастающую последовательность [1, 2]. Кроме того, вы можете удалить 2, чтобы получить строго возрастающую последовательность [1, 3].

Ввод, вывод

[ограничение по времени] 4000 мс (руб.) [вход] последовательность array.integer

Ограничения: 2 ≤ sequence.length ≤ 105, -105 ≤ sequence [i] ≤ 105.

[выходной] логический

Вернуть true, если возможно удалить один элемент из массива, чтобы получить строго возрастающую последовательность, в противном случае вернуть false.

Ниже приведен код, который я пытаюсь. Я заскочил puts "#{prev}" несколько раз, чтобы увидеть, что prev устанавливается первоначально после 1 добавлен в wrong и в самом конце, так что последний prev записано.

def almostIncreasingSequence(sequence)
  prev = [sequence[0], sequence[1]].min
  puts "#{prev}"
  wrong = 0
  (sequence.length - 1).times do |num|
    if prev < sequence[num + 1]
      prev = sequence[num + 1]
    else
      wrong += 1
      return false if wrong == 2
      puts "#{prev}"
    end
  end
  puts "#{prev}"
  true
end

Это единственный тест, который не пройдет сейчас:

(almostIncreasingSequence([1, 2, 3, 4, 99, 5, 6]) 

Это должно быть правдой, потому что 99 можно вытащить, и возрастающая последовательность может продолжаться. Но false возвращается вроде бы после wrong добавляется только один раз.

Код должен вернуться false если wrong == 2 От puts "#{prev}" выходной, я вижу, что prev берет свое начало в 1 и wrong срабатывает, когда 99 больше чем 5 и с тех пор wrong должен быть только в 1 Я не понимаю, почему это возвращается false немедленно. Я могу пройти этот тест, если я установлю prev = sequence[num - 1] после wrong добавляется в первый раз, но тогда многие другие тесты не пройдут. Вот список других тестов, которые я пробую. Большинство тестов, которые Codefights требует от вас, чтобы перейти к следующему тренировочному коду.

(almostIncreasingSequence([1, 3, 2])) #true
(almostIncreasingSequence([1, 2, 1, 2])) #false
(almostIncreasingSequence([10, 1, 2, 3, 4, 5])) #true
(almostIncreasingSequence([0, -2, 5, 6]) )#true
(almostIncreasingSequence([1, 2, 3, 4, 5, 3, 5, 6])) #false
(almostIncreasingSequence([40, 50, 60, 10, 20, 30])) #false
(almostIncreasingSequence([1, 2, 3, 4, 3, 6])) #true
(almostIncreasingSequence([100, 200, 300, 400, 99, 500, 600])) #true
(almostIncreasingSequence([1, 3, 2, 1])) #false
(almostIncreasingSequence([1, 4, 10, 4, 2])) #false
(almostIncreasingSequence( [1, 1, 1, 2, 3])) #false
(almostIncreasingSequence([1, 1])) #true
(almostIncreasingSequence([10, 1, 2, 3, 4, 5, 6, 1])) #false

Заранее спасибо за любой свет, который вы можете пролить на эту проблему.

Answer 1

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

Суть вашей проблемы в том, что когда вы увеличиваете неправильно, ваш prev значение остается равным 99 что делает каждое последующее значение неправильным. Вам нужно установить prev в sequence[num - 1] чтобы предотвратить это, но, как вы сказали, это вызывает ошибки. Это потому, что когда вы удаляете неправильное число из массива (т.е. [1, 2, 1, 2] -> [1, 1, 2] вам нужно еще раз проверить, работают ли два последовательных числа, которые в данном случае не работают.

Вы можете это исправить, но тогда вы столкнетесь с другой ошибкой в ​​таких ситуациях, как [10, 1, 2, 3, 4, 5]where your startingзначение prev` на самом деле не ваше первое значение.

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