Arithmetic sequence - checking - c++

Question

What is the most efficient way to check whether you can create an arithmetic sequence from the specified sequence of numbers?
Currently I sort the sequence and then do this:
#include<bits/stdc++.h>
using namespace std;
static bool sort_using_greater_than(float u, float v)
{
return u > v;
}
int main()
{
int licznik=0, i=0;
double number[100000];
while(~scanf("%f", &number[i]))
{
i++;
licznik++;
}
sort(number,number+100, sort_using_greater_than);
for(int i = 1; i < licznik-1; i++)
{
if(number[i] - number[i+1] != number[0] - number[1])
{
puts("NO");
return 0;
}
}
puts("YES");
}
For test:
1.0 5.0
My code return YES, why?
enter code here
double search_min(double tab[], int n)
{
double min = tab[0];
for(int i = 1; i < n; i++)
{
if(min > tab[i])
min = tab[i];
return min;
}
And, How I can find two smallest element?

Answer 1

The question is unclear but if it means "check that the given numbers can be rearranged to from a single arithmetic sequence", then there is no need to sort.
find the smallest element, in O(N), let a;
find the second smallest, in O(N), let b;
clear an array of N bits in O(N);
for every number c, compute (c - a) / (b - a); if this isn't an integer in range [0,n-1], the answer is no. Otherwise, set the bit at that index (done in O(1) per element);
check that all bits have been set in O(N).
The whole process takes time O(N).

Answer 2

O(n) is the best you are going to get simply by the nature that you must check every element.
I've implemented Yves Daoust's algorithm (with some minor optimizations) as well as your own in C++14 standard code.
Here is yours:
int main(int argc, char* argv[]) {
if(argc == 1) return 0;
//Copy command args to vector of strings.
std::size_t number_count = argc - 1;
std::vector<std::string> cmd_args(number_count);
std::copy(argv + 1, argv + argc, cmd_args.begin());
//Copy convert vector of strings to vector of ints.
std::vector<int> values(number_count);
auto v_begin = values.begin();
for(auto s : cmd_args) {
(*v_begin) = std::stoi(s);
++v_begin;
}
//Sort values in ascending order.
std::sort(values.begin(), values.end());
//Get smallest two values.
std::pair<int, int> two_smallest_values(*values.cbegin(), *(values.cbegin() + 1));
//Calculate differences between each successive number
std::vector<int> differences(values.size() - 1);
for(std::size_t i = 0; i < values.size() - 1; ++i) {
differences[i] = std::abs(values[i] - values[i + 1]);
}
//All values in differences must be the same.
if(std::all_of(differences.cbegin(), differences.cend(), [=](int i) { return i == *differences.cbegin(); })) {
std::cout << "YES\n";
} else {
std::cout << "NO\n";
}
return 0;
}
Here is Yves Daoust's algorithm:
int main(int argc, char* argv[]) {
if(argc == 1) return 0;
//Copy command args to vector of strings.
std::size_t number_count = argc - 1;
std::vector<std::string> cmd_args(number_count);
std::copy(argv + 1, argv + argc, cmd_args.begin());
//Copy convert vector of strings to vector of ints.
auto v_begin = values.begin();
for(auto s : cmd_args) {
(*v_begin) = std::stoi(s);
++v_begin;
}
//Sort values in ascending order.
std::sort(values.begin(), values.end());
//Get smallest two values.
std::pair<int, int> two_smallest_values(*values.cbegin(), *(values.cbegin() + 1));
std::vector<bool> bits(values.size());
bool result = true;
int smallest_diff = (two_smallest_values.second - two_smallest_values.first);
for(auto v : values) {
int numerator = v - two_smallest_values.first;
int denominator = smallest_diff;
if(numerator % denominator != 0) {
result = false;
break;
}
std::size_t i = numerator / denominator;
if(i < 0 || i >= values.size()) {
result = false;
break;
}
bits[i] = true;
}
if(result == false) {
std::cout << "NO\n";
return 0;
}
//Convert vector of bools (bit-packed) to an unsigned int.
unsigned long long bits_value = 0;
unsigned long long i = 0;
for(auto b : bits) {
bits_value |= (b << i++);
}
//Optimization: Single calculation to determine if all bits are set:
if(std::abs(bits_value - (std::pow(2.0, bits.size()) - 1) < 0.01)) {
std::cout << "YES\n";
} else {
std::cout << "NO\n";
}
return 0;
}