#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <random>
#include <chrono>
std::vector<int> generate_table(int n)
{
std::vector<int> table;
table.reserve(n);
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<int> dist(1, 99999999);
for (int i = 0; i < n; i++)
{
table.emplace_back(dist(gen));
}
return table;
}
int absolute(int val)
{
if (val < 0)
return -val;
else
return val;
}
int max_e(const std::vector<int>& elements)
{
int max;
max = elements[0];
for (auto e : elements)
{
if (e > max)
max = e;
}
return max;
}
int min_e(const std::vector<int>& elements)
{
int min;
min = elements[0];
for (auto e : elements)
{
if (e < min)
min = e;
}
return min;
}
int get_n_sub_tables(std::vector<int>& table, int difference)
{
int counter = 0;
for (auto start_e = table.begin(); start_e != table.end(); ++start_e)
{
counter++;
auto max = start_e;
for (auto cur_e = start_e + 1; cur_e != table.end(); ++cur_e)
{
int d = *max - *cur_e;
if (absolute(d) <= difference)
{
std::vector<int> temp;
for (auto i = start_e; i != cur_e + 1; ++i)
{
temp.emplace_back(*i);
}
if ((max_e(temp) - min_e(temp) <= difference))
{
counter++;
}
if (d < 0)
max = cur_e;
}
else
{
break;
}
}
}
return counter;
}
std::vector<std::vector<int>> get_sub_tables(std::vector<int>& table, int difference)
{
std::vector<std::vector<int>> sub_tables;
for (auto start_e = table.begin(); start_e != table.end(); ++start_e)
{
sub_tables.emplace_back(std::vector<int>{*start_e});
auto max = start_e;
for (auto cur_e = start_e + 1; cur_e != table.end(); ++cur_e)
{
int d = *max - *cur_e;
if (absolute(d) <= difference)
{
std::vector<int> temp;
for (auto i = start_e; i != cur_e + 1; ++i)
{
temp.emplace_back(*i);
}
if ((max_e(temp) - min_e(temp) <= difference))
{
sub_tables.emplace_back(temp);
}
if (d < 0)
max = cur_e;
}
else
{
break;
}
}
}
return sub_tables;
}
std::vector<std::vector<int>> get_sub_tables_debug(std::vector<int>& table, std::vector<std::vector<int>>& correct, int difference)
{
std::vector<std::vector<int>> sub_tables;
for (auto start_e = table.begin(); start_e != table.end(); ++start_e)
{
sub_tables.emplace_back(std::vector<int>{*start_e});
auto max = start_e;
for (auto cur_e = start_e + 1; cur_e != table.end(); ++cur_e)
{
int d = *max - *cur_e;
if (absolute(d) <= difference)
{
std::vector<int> temp;
for (auto i = start_e; i != cur_e + 1; ++i)
{
temp.emplace_back(*i);
}
if (std::find(correct.begin(), correct.end(), temp) == correct.end())
{
std::cout << "table: [";
for (auto e : temp)
{
std::cout << e << " ";
}
std::cout << "] does not match \n";
}
sub_tables.emplace_back(temp);
if (d < 0)
max = cur_e;
}
else
{
break;
}
}
}
return sub_tables;
}
int n_subs(const std::vector<int>& table, int differece)
{
int n_sub_tables = 0;
for (auto left_i = table.begin(); left_i != table.end(); ++left_i)
{
n_sub_tables++;
int max = *left_i;
int n_digits = 1;
for (auto right_i = left_i + 1; right_i != table.end(); )
{
int d = max - *right_i;
if (d < 0)
max = *right_i;
if (absolute(d) <= differece)
{
if (right_i - left_i >= n_digits)
{
n_sub_tables++;
if (right_i - left_i >= n_digits)
{
n_digits++;
right_i = left_i + 1;
max = *left_i;
continue;
}
}
else
++right_i;
}
else
break;
}
}
return n_sub_tables;
}
//int main()
//{
// int d = 99999999;
// for (int n = 0; n < 2000; n++)
// {
// auto table = generate_table(n);
// std::cout << "results for n: " << n << '\n';
// int correct = get_sub_tables(table, d).size();
// int new_alg = n_subs(table, d);
// std::cout << "correct: " << correct << '\n';
// std::cout << "new: " << new_alg << '\n';
// if (new_alg != correct)
// std::cout << "bad";
// }
// return 0;
//}
int main()
{
int n;
int d;
std::vector<int> table;
std::cin >> n;
std::cin >> d;
for (int temp, i = 0; i < n; i++)
{
std::cin >> temp;
table.emplace_back(temp);
}
std::cout << n_subs(table, d);
return 0;
}
/*
std::vector<int> generate_table(int n)
{
std::vector<int> table;
table.reserve(n);
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<int> dist(1, 99999999);
for (int i = 0; i < n; i++)
{
table.emplace_back(dist(gen));
}
return table;
}
std::vector<std::vector<int>> get_all_sub_tables(std::vector<int>& table)
{
std::vector<std::vector<int>> sub_tables;
for (int n_digit = 1; n_digit <= table.size(); n_digit++)
{
for (auto left_i = table.begin(); left_i != table.end(); ++left_i)
{
if (table.end() - left_i < n_digit)
break;
std::vector<int> sub_nums;
for (auto right_i = left_i; right_i != left_i + n_digit; ++right_i)
{
if (right_i == table.end())
break;
sub_nums.emplace_back(*right_i);
}
sub_tables.emplace_back(sub_nums);
}
}
return sub_tables;
}
std::vector<std::vector<int>> get_sub_tables_d(const std::vector<std::vector<int>>& sub_tables, int difference)
{
std::vector<std::vector<int>> sub_tables_d;
for (auto table = sub_tables.begin(); table != sub_tables.end(); ++table)
{
int min = *std::min_element(table->begin(), table->end());
int max = *std::max_element(table->begin(), table->end());
if ((max - min) <= difference)
{
sub_tables_d.emplace_back(*table);
}
}
return sub_tables_d;
}
std::vector<std::vector<int>> get_sub_tables_perdigit(std::vector<int>& table, int difference)
{
std::vector<std::vector<int>> sub_tables;
for (int n_digit = 1; n_digit <= table.size(); n_digit++)
{
int min;
for (auto left_i = table.begin(); left_i != table.end(); ++left_i)
{
if (table.end() - left_i < n_digit)
break;
min = *left_i;
std::vector<int> sub_nums;
for (auto right_i = left_i; right_i != left_i + n_digit; ++right_i)
{
int d = min - (*right_i);
if (std::abs(d) <= difference)
{
sub_nums.emplace_back(*right_i);
if (d > 0)
min = *right_i;
}
else
break;
if (right_i == table.end())
break;
}
if (sub_nums.size() == n_digit)
{
int d = max_e(sub_nums) - min_e(sub_nums);
if (abs(d) <= difference)
{
sub_tables.emplace_back(sub_nums);
}
}
}
}
return sub_tables;
}
void print_sub_tables(const std::vector<std::vector<int>>& source)
{
for (auto table : source)
{
std::cout << "[ ";
for (auto element : table)
{
std::cout << element << " ";
}
std::cout << "]";
}
}
*/