I need to get number of character in array.
const char myarray[5] = {'0', 'a', 'e', 'f', 'c'}; // Create array of char
int number=0; // Create variable
number = getposition(myarray, 'f'); // Now number equals to 3
number = getposition(myarray, 'z'); // -1, because array doesn't have this char
My task is easy because array don't have repeating characters (for example, it can't be smth like this: {'a', '1', 'f', 'a'}). How can I do it?
A little bit more C++:
#include <algorithm>
int getposition(const char *array, size_t size, char c)
{
const char* end = array + size;
const char* match = std::find(array, end, c);
return (end == match)? -1 : (match-array);
}
A lot more C++:
template <typename T, size_t N>
int getposition(const T (&array)[N], const T c)
{
const T* match = std::find(array, array+N, c);
return (array+N==match)? -1 : std::distance(array, match);
}
#include <algorithm>
#include <iterator>
template <typename Range, typename T>
size_t index_of(Range const& range, T const& c) {
using std::begin;
using std::end;
auto b = begin(range), e = end(range);
auto match = std::find(b, e, c);
return (e==match)? -1 : std::distance(b, match);
}
Here, the original question gets direct support in std::string_view:
#include <string_view>
using namespace std::string_view_literals;
int main() {
return "hello"sv.find('e');
}
memchr (mentioned by another poster). The problem is a classical linear search, and you don't reinvent the wheel (unless that is the target of the exercise).
strlen instead of the size parameter, and we don't know whether the array is a string (the one in the example isn't) and if so whether the 0 terminator is supposed to be searched or not. But otherwise it's basically the right thing. You could have an "even more C++" version using std::begin(array), std::end(array), although then it also wouldn't need to advertise the template deduction trick for capturing N, because it could just take a single template argument Range.
#include <algorithm>
template <typename T, size_t size>
int getposition(T const (&array)[size], T const & c)
{
T const * found = std::find(&array[0], &array[size], c);
return found == &array[size] ? -1 : found - array;
}
found - array were replaced by std::distance(array,found).
the type T was missing in the second parameter. Hope it is okay with you.T.You need to tell the getposition() method how many elements to search within the array and as the array is initialised at compile time you can use the sizeof directive:
int number = getposition(myarray, sizeof(myarray), 'f');
...
int getposition(const char *array, size_t size, char c)
{
for (size_t i = 0; i < size; i++)
{
if (array[i] == c)
return (int)i;
}
return -1;
}
break statements wouldn't help either.break (or a more complicated termination condition), and a variable to store the return value, in order to follow your advice and avoid an early return. Or do you have a suggestion that avoids an early return and somehow manages to be more legible than this?
return is king - his answer is way more complicated than it needs to be and maintenance would be a real concern.int getposition(const char* a, int arr_size, char to_find)
{
int pos = -1;
for(int i = 0; i < arr_size; ++i)
{
if(a[i] == to_find)
{
pos = i;
break;
}
}
return pos;
}
If this really is a pure decoding exercise - why not re-organize your array... then lookup is constant time - e.g..
int lt[128]; // ignoring negative values..
memset(lt, -1, 128); // initialize all to -1
// set the ones you want mappings for..
lt['0'] = 0;
lt['a'] = 1;
lt['e'] = 2;
lt['f'] = 3;
lt['c'] = 4;
so now your look up function is:
int indexOf(char v) { return lt[v]; }
You'd be hard-pressed to beat that for performance...
You need to pass the array size as well to the function.
int getposition(const char* array, size_t array_size, char value)
{
int ret = -1;
int i = 0;
bool found = false;
while (i < array_size && !found)
{
found = (array[i++] == value);
}
if (found)
{
ret = i - 1;
}
return ret;
}
!found condition. Adding an explicit return would have prevented that :). But I downvoted because you wrote the function instead of using the standard library.return, that's the point ;)const char *. You shouldn't initialise an unsigned type (ret) with -1 and boolean isn't a valid C++ keyword. This question was about the size of an array, not how to program dogmatically.
memchris your friend - unless this is homework - in which case - you should think about it....