How to identify an embedded palindrome within an array of digits - arrays
Say we have
int arr1[]={1,2,3,4,5};
int temp1[], temp2[];
and that we need to copy the first 3 members from arr1 to temp1, and the second 3 from arr1 to temp2, so that
temp1={1,2,3};
temp2={2,3,4};
and so on and so forth, how would you go on about doing it? I am trying to write a program to check if a user inputted number contains a palindrome in a length k (where k is also chosen by the user) and my idea was to store the number in an array, take the first 3 members, put them in an array, reverse them and put that in another array and then compare, but I am stuck on how to solve the problem I mentioned above, I tried something like:
void copyandReverse(int arr[], int copy[], int reverse[], int start, int length)
{
for(int i=0; i<length; i++)
{
copy[start+i]=arr[start+i];
reverse[start+i]=arr[start+length-i-1];
}
}
but it seems to only copy the first 3 elements, and reverse them.
PS: I don't think we're allowed to use string or dynamic memory allocation, it's given that the inputted number contains less then 10 digits, so I made the temporary arrays with a constant size 10.
There is no any need to create auxiliary arrays to check whether a given array is a palindrome.
This can be done much simpler.
Write a function like this
int is_palindrome( const unsigned int a[], size_t n )
{
size_t i = 0;
while (i < n / 2 && a[i] == a[n - i - 1]) ++i;
return i == n / 2;
}
then in main if you have an array like
unsigned int a[10];
and you need to check whether a sub-array with three elements is a palindrome then you can do this in a for loop
size_t k = 3;
for ( size_t i = 0; i <= 10 - k; i++ )
{
if ( is_palindrome( a + i, k ) )
{
printf( "The sub-array at position %zu:", i );
for ( size_t j = i; j < k + i; j++ ) printf( " %u", a[j] );
puts( " is a palindrome" );
}
}
as #stark mentioned, just iterate over the array with two indices.
Please see an example implementation below. You just need to evaluate the actual size from the userinput before you validate it.
The code below assumes 0 as the delimited. After gathering the actual user input size, we start a loop with index i and j. Looping until they have swapped positions.
If a mismatch exists, we return FALSE, otherwise TRUE.
#include <stdio.h>
#define TRUE 1
#define FALSE 0
size_t getUserInputLength(int *arr, size_t len)
{
for (size_t i = 0; i < len; i++)
{
if (arr[i] == 0)
{
return i;
}
}
return len;
}
int checkPalindrome(int *arr, size_t len)
{
size_t i, j;
for (i = 0, j = len - 1; i <= j; i++, j--)
{
printf("Current indices: [i: %ld, j: %ld]\n", i, j);
printf("Current values: [i: %d, j: %d]\n", arr[i], arr[j]);
if (arr[i] != arr[j])
{
return FALSE;
}
}
return TRUE;
}
int main()
{
// even number of user input
int evenInput[] = {1, 2, 3, 4, 3, 2, 1, 0, 0, 0};
size_t evenLen = getUserInputLength(evenInput, 10);
printf("Even number returned: %d\n", checkPalindrome(evenInput, evenLen));
// odd number of user input
int oddInput[] = {1, 2, 3, 2, 1, 0, 0, 0, 0, 0};
size_t oddLen = getUserInputLength(oddInput, 10);
printf("Odd number returned: %d\n", checkPalindrome(oddInput, oddLen));
return 0;
}
Related
Want to access arr[n] in printf but the given n is above the actual elements in an array? [C]
CSS student here. I was given an exercise by my prof but I don't know how to solve this problem. A specific n is wanting to be accessed in printf but the given elements in the array are below the n that is asked. This is the code I wrote but in this paticular test it's not giving me the right solution. Any tips? #include <stdio.h> int max(int arr[], int n) { int numMax = 0, indexMax = 0; for (int i = 0; i <= n; i++) { if (arr[i] >= numMax) { numMax = arr[i]; indexMax = i; } } return indexMax; } int main () { int arr[5]={-88, -91, -45, -90, -13}; printf("The index of the highest number is: %d\n", max(feld, 5)); // solution: 5 return 1; }
Your array is called arr and not feld. In your function you can initialize numMax with the first value of the array and then loop through it to test the following ones. #include <stdio.h> int max(int arr[], int n) { int numMax = arr[0], indexMax = 0; for (int i = 1; i < n; i++) { if (arr[i] >= numMax) { numMax = arr[i]; indexMax = i; } } return indexMax; } int main(void) { int arr[5] = {-88, -91, -45, -90, -13}; printf("The index of the highest number is: %d\n", max(arr, 5)); return 0; }
With: for (int i = 0; i <= n; i++), the OP program is stepping out of the boundaries of the array. (zero based indexing is tricky for beginners.) The array elements aren't going anywhere. Simply pick the last element, and update that pick if a higher value is found during a scan toward the 0th element. int maxVal( int arr[], int n ) { int maxInd = --n; while( --n >= 0 ) if( arr[n] > arr[MaxInd] ) maxInd = n; return maxInd; } Fewer variables to keep track of is always an advantage. The function returns the index, not the value. printf("The index of the highest number is: %d\n", max(arr, 5) ); EDIT: Let's visit main() to improve it a bit. int main( void ) { // more conventional // the compiler counts more accurately than most people: int arr[] = { -88, -91, -45, -90, -13 }; size_t nElem = sizeof arr/sizeof arr[0]; // Notice that maxVal() should return a 'size_t', too. // Use the appropriate format specifier // The name "maxVal()" is misleading. Fix that... printf("The index of the highest number is: %sz\n", maxValInd( arr, nElem ) ); return 0; // 0 means all good, non-zero indicates an error occurred. } Now, since that uses size_t (better for non-negative values like the number of elements in an array or bytes in a file), we should improve the function, too: size_t maxValInd( int arr[], size_t n ) { size_t maxInd = 0; // pick 0th as first pick... while( --n > 0 ) // test all values down to, but not, arr[0]. if( arr[n] > arr[MaxInd] ) maxInd = n; return maxInd; } NB: size_t is an unsigned datatype that will underflow if decremented below zero. Handle with care to avoid infinite-loops.
int arr[6] and passing 5 as argument to max should do the work.
how can I use less variables in my program?
I had to make a program that have an array of numbers, and then I need to make a function that get the arr[0] and the length of the array, and then it will print all the numbers without the duplicate ones. I made this program and it worked good but I feel like I used too much variables for this program. (I started to learned in the last few weeks so its not looks very good) #include <stdio.h> #define N 10 void print_set(int *arr, int n) { int i = 1; int duplicate_num, check_num, count; printf(" %d", *arr); //printing the first number (arr[0]). //starting to check the other number. if they new I'll print them. (start from arr[1]). arr++; while (i < n) { if (*arr != duplicate_num) { printf(" %d", *arr); check_num = *arr; // becouse I found new number, I change it no be equal to the first duplicate_num. (if there are more like him, I change them too). while (i < n) { if (*arr == check_num) { *arr = duplicate_num; } arr++; i++; count++; } i = i - count; arr = arr - count; count = 0; } arr++; i++; } } int main() { int arr[N] = {4, 6, 9, 8, 6, 9, 6, 1, 6, 6}; print_set(&arr[0], N); return 0; } output for this program: 4 6 9 8 1 I'll be happy to see good method to make this program less messy.
For starters the function has undefined behavior. The user can pass 0 as the second argument. It means that the array is empty and has no elements. In this case the expression *arr is undefined. The second problem is using the uninitialized variable duplicate_num in this if statement if (*arr != duplicate_num) { and the uninitialized variable count count++; Another problem is that the function changes the array if (*arr == check_num) { *arr = duplicate_num; } If you need only to output unique values in an array then the source array shall not be changed. The function can be defined for example the following way void print_set( const int *a, size_t n ) { for ( size_t i = 0; i < n; i++ ) { size_t j = 0; while ( j != i && a[i] != a[j] ) ++j; if ( j == i ) printf( "%d ", a[i] ); } putchar( '\n' ); }
How can I print the number of unique elements instead of show the elements itself in my code?
I want to print the number of unique elements instead of show the elements For example show 4. Means we have 4 unique elements #include<stdio.h> #define max 100 int ifexists(int z[], int u, int v) { int i; for (i=0; i<u;i++) if (z[i]==v) return (1); return (0); } void main() { int p[max], q[max]; int m; int i,k; k=0; printf("Enter length of the array:"); scanf("%d",&m); printf("Enter %d elements of the array\n",m); for(i=0;i<m;i++ ) scanf("%d",&p[i]); q[0]=p[0]; k=1; for (i=1;i<m;i++) { if(!ifexists(q,k,p[i])) { q[k]=p[i]; k++; } } printf("\nThe unique elements in the array are:\n"); for(i = 0;i<k;i++) printf("%d\n",q[i]); } https://onlinegdb.com/Bk3tvQMpw
Sort the array then iterate through the elements and print out if the current element is different than the last: int cmpint(const void *a, const void *b) { return *(int *) a) < *(int *) b : -1 ? ( *(int *) b) < *(int *) a ? 1 : 0 ); } int main() { /* ... */ qsort(p, m, sizeof(*p), cmpint); int n = 0; for(int i = 0; i < m; i++) { if(!i || p[i-1] != p[i]) n++; } printf("Number of unique elements: %d\n", n); } where p is your now sorted array and length is m as per example code. As qsort is expected O(m *log(m)) so will this aglorithm. If you don't sort the array it will be O(m^2) due to m linear searches.
If I have understood the question correctly what you need is to count unique elements in an array using a function and without defining an auxiliary array. That is there is no need to output the unique elements themselves. In this case the corresponding function can look the following way as it is shown in the demonstrative program below. #include <stdio.h> int is_unique( const int a[], size_t n, int value ) { while ( n != 0 && a[ n - 1 ] != value ) --n; return n == 0; } int main(void) { int a[] = { 1, 2, 3, 3, 2, 1 }; const size_t N = sizeof( a ) / sizeof( *a ); size_t count = 0; for ( size_t i = 0; i < N; i++ ) { count += is_unique( a, count, a[i] ); } printf( "There are %zu unique elements in the array.\n", count ); return 0; } The program output is There are 3 unique elements in the array. If you do not want to define one more function to count unique elements in an array then just move the loop in the function shown in the above demonstrative program inside main. Here you are. #include <stdio.h> int main(void) { int a[] = { 1, 2, 3, 3, 2, 1 }; const size_t N = sizeof( a ) / sizeof( *a ); size_t count = 0; for ( size_t i = 0; i < N; i++ ) { size_t j = i; while ( j != 0 && a[j - 1] != a[i] ) --j; count += j == 0; } printf( "There are %zu unique elements in the array.\n", count ); return 0; } The program output is the same as shown above that is There are 3 unique elements in the array. Pay attention to that according to the C Standard the function main without parameters shall be declared like int main( void ) instead of void main()
Is there a algorithm to print all arrengments of subsequences of an array?
I am working with combinatorics and I would like to know if there is an algorithm that prints all arrangments of subsequences of a given array. That is, if I give to this algorithm the sequence "ABCDEF" it will print : A, B, C, D, E, F, AB, AC, AD, AE, AF, BC, BD, BE, BF, CD, CE, CF, DE, DF, EF, ABC, ABD, ABE, ABF, ACD, ACE, ACF, ADE, ADF, AEF, BCD, BCE, BCF, BDE, BDF, BEF, CDE, CDF, CEF, DEF, ABCD, ABCE, ABCF, ABDE, ABDF, ABEF, ACDE, ACDF, ACEF, ADEF, BCDE, BCDF, BCEF, BDEF, CDEF, ABCDE, ABCDF, ABCEF, ABDEF, ACDEF, BCDEF, ABCDEF, or for a more simple case, if i give it 1234, it will print: 1,2,3,4,12,13,14,23,24,34,123,124,134,234,1234. As you can see it is not an arbitrary permutation it is only the permutation of the last members of a subsequence in a way it still reains a subsequence. I have tried to make a function in c that does this but i got really confused, my idea would be to make a int L that keeps the size of the subsequence,and another tree integers one that keeps the head of the subsequence, one that marks the separation from the head and one that slides trought the given number of characters, but it gets too confused too quickly. Can anyone help me with this ? my code is: int Stringsize( char m[] ){ int k; for(k=0;;k++){ if( m[k] == '\0') break; } return (k-1); } void StringOrdM(char m[]){ int q,r,s,k; for(k=0;k<=Stringsize(m);k++) for(q=0;q<=Stringsize(m);q++) for(s=q;s<=Stringsize(m);s++ ) printf("%c",m[q]); for(r=q+1; r<=Stringsize(m) && (r-q+1)<= k ;r++ ) printf("%c", m[r] ); } And for ABCD it prints A,A,A,A,B,B,B,C,C,D,AA,AB,AC,AD,BC,BD,CC,CD,DD,... so it is not right because it keeps repeating the A 4 times the B three times and so on, when it should have been A,B,C,D,AB,AC,AD,BC,BD,CD,...
As I said in my comment above, one solution is simple: count in binary up to (1<<n)-1. So if you have four items, count up to 15, with each bit pattern being a selection of the elements. You'll get 0001, 0010, 0011, 0100, 0101, 0110, 0111, 1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111. Each bit is a true/false value as to whether to include that element of the array. #include <stdio.h> int main(void) { //////////////////////////////////////////////////////////////////////// int A[] = { 1, 2, 3, 4, 5 }; //////////////////////////////////////////////////////////////////////// size_t len = sizeof A / sizeof A[0]; // Array length (in elements) size_t elbp = (1<<len) - 1; // Element selection bit pattern size_t i, j; // Iterators // Cycle through all the bit patterns for (i = 1; i<=elbp; i++) { // For each bit pattern, print out the 'checked' elements for (j = 0; j < len; j++) { if (i & (1<<j)) printf("%d ", A[j]); } printf("\n"); } return 0; } If you want the elements sorted shortest to longest, you could always store these results in a string array (using sprintf()) and then sort (using a stable sorting algorithm!) by string length.
I mentioned in a comment above that if you didn't want to use a bit pattern to find all permutations, and sort the results according to whatever criteria you'd like, you could also use a recursive algorithm. I suspect this is a homework assignment, and you only asked for an algorithm, so I left some of the key code as an exercise for you to finish. However, the algorithm itself is complete (the key parts are just described in comments, rather than functional code being inserted). #include <stdio.h> #include <stdlib.h> #include <string.h> void printpermutations(const int *A, const size_t n, const char *pfix, const size_t rd); int main(void) { ///////////////////////////////////////////////////////////////////// int A[] = { 1, 2, 3, 4, 5 }; ///////////////////////////////////////////////////////////////////// size_t n = sizeof A / sizeof A[0]; // Array length (in elements) size_t i; // Iterator for (i = 1; i <= n; i++) { printpermutations(A, n, "", i); } return 0; } // Recursive function to print permutations of a given length rd, // using a prefix set in pfix. // Arguments: // int *A The integer array we're finding permutations in // size_t n The size of the integer array // char *pfix Computed output in higher levels of recursion, // which will be prepended when we plunge to our // intended recursive depth // size_t rd Remaining depth to plunge in recursion void printpermutations(const int *A, const size_t n, const char *pfix, const size_t rd) { size_t i; char newpfix[strlen(pfix)+22]; // 20 digits in 64-bit unsigned int // plus a space, plus '\0' if (n < rd) return; // Don't bother if we don't have enough // elements to do a permutation if (rd == 1) { for (i = 0; i < n; i++) { // YOUR CODE HERE // Use printf() to print out: // A string, consisting of the prefix we were passed // Followed immediately by A[i] and a newline } } else { strcpy(newpfix, pfix); for (i = 1; i <= n; i++) { // YOUR CODE HERE // Use sprintf() to put A[i-1] and a space into the new prefix string // at an offset of strlen(pfix). // Then, call printpermutations() starting with the ith offset into A[], // with a size of n-i, using the new prefix, with a remaining // recursion depth one less than the one we were called with } } }
Depending on torstenvl's answer I did this code and It works perfectly. If there is any problem let me know. #include <stdio.h> #include <stdlib.h> #include <string.h> int main(void) { char str[] = "1234"; size_t len = strlen(str); // Array length (in elements) char *A = malloc(sizeof(char) * len); strcpy(A,str); size_t elbp = (1<<len) - 1; // Element selection bit pattern size_t i, j; // Iterators int a = 0, b = 0, n = 0; char **arr = malloc(sizeof(char*) * (10000)); //allocating memory if (A[0] >= 'A' && A[0] <= 'Z') //If the string given is "ABCD...." transfer 'A' to '1' ; 'C' to '3' ...etc for(int i = 0; i < len; i++) A[i] = A[i] - 'A' + '1'; // Cycle through all the bit patterns for (i = 1; i<=elbp; i++) { arr[b] = malloc(sizeof(char) * len); // For each bit pattern, store in arr[b] the 'checked' elements for (j = 0, a = 0; j < len; j++) if (i & (1<<j)) arr[b][a++] = A[j]; b++; } int *num = calloc(sizeof(int) ,10000); for (i = 0; i < b; i++) num[i] = strtol(arr[i], NULL, 10); //convert char to int for (i = 0; i < b; i++) //sort array numbers from smallest to largest for (a = 0; a < i; a++) if (num[i] < num[a]) { n = num[i]; num[i] = num[a]; num[a] = n; } char *result = calloc(sizeof(char),10000); for (i = 0, a = 0; i<b; i++) a += sprintf(&result[a], "%d,", num[i]); //convert int to char and store it in result[a] result[a - 1] = '\0'; //remove the last ',' len = strlen(result); if (str[0] >= 'A' && str[0] <= 'Z') //if the string given is "ABCD..." transfer '1' to 'A' ; '12' to 'AB' ; '13' to 'AC'.....etc for (i = 0; i < len; i++) if(result[i] != ',') result[i] = 'A' + (result[i] - '1') ; ///test printf("%s",result); return 0; } the output for "1234": 1,2,3,4,12,13,14,23,24,34,123,124,134,234,1234 the output for "123456789": 1,2,3,4,5,6,7,8,9,12,13,14,15,16,17,18,19,23,24,25,26,27,28,29,34,35,36,37,38,39,45,46,47,48,49,56,57,58,59,67,68,69,78,79,89,123,124,125,126,127,128,129,134,135,136,137,138,139,145,146,147,148,149,156,157,158,159,167,168,169,178,179,189,234,235,236,237,238,239,245,246,247,248,249,256,257,258,259,267,268,269,278,279,289,345,346,347,348,349,356,357,358,359,367,368,369,378,379,389,456,457,458,459,467,468,469,478,479,489,567,568,569,578,579,589,678,679,689,789,1234,1235,1236,1237,1238,1239,1245,1246,1247,1248,1249,1256,1257,1258,1259,1267,1268,1269,1278,1279,1289,1345,1346,1347,1348,1349,1356,1357,1358,1359,1367,1368,1369,1378,1379,1389,1456,1457,1458,1459,1467,1468,1469,1478,1479,1489,1567,1568,1569,1578,1579,1589,1678,1679,1689,1789,2345,2346,2347,2348,2349,2356,2357,2358,2359,2367,2368,2369,2378,2379,2389,2456,2457,2458,2459,2467,2468,2469,2478,2479,2489,2567,2568,2569,2578,2579,2589,2678,2679,2689,2789,3456,3457,3458,3459,3467,3468,3469,3478,3479,3489,3567,3568,3569,3578,3579,3589,3678,3679,3689,3789,4567,4568,4569,4578,4579,4589,4678,4679,4689,4789,5678,5679,5689,5789,6789,12345,12346,12347,12348,12349,12356,12357,12358,12359,12367,12368,12369,12378,12379,12389,12456,12457,12458,12459,12467,12468,12469,12478,12479,12489,12567,12568,12569,12578,12579,12589,12678,12679,12689,12789,13456,13457,13458,13459,13467,13468,13469,13478,13479,13489,13567,13568,13569,13578,13579,13589,13678,13679,13689,13789,14567,14568,14569,14578,14579,14589,14678,14679,14689,14789,15678,15679,15689,15789,16789,23456,23457,23458,23459,23467,23468,23469,23478,23479,23489,23567,23568,23569,23578,23579,23589,23678,23679,23689,23789,24567,24568,24569,24578,24579,24589,24678,24679,24689,24789,25678,25679,25689,25789,26789,34567,34568,34569,34578,34579,34589,34678,34679,34689,34789,35678,35679,35689,35789,36789,45678,45679,45689,45789,46789,56789,123456,123457,123458,123459,123467,123468,123469,123478,123479,123489,123567,123568,123569,123578,123579,123589,123678,123679,123689,123789,124567,124568,124569,124578,124579,124589,124678,124679,124689,124789,125678,125679,125689,125789,126789,134567,134568,134569,134578,134579,134589,134678,134679,134689,134789,135678,135679,135689,135789,136789,145678,145679,145689,145789,146789,156789,234567,234568,234569,234578,234579,234589,234678,234679,234689,234789,235678,235679,235689,235789,236789,245678,245679,245689,245789,246789,256789,345678,345679,345689,345789,346789,356789,456789,1234567,1234568,1234569,1234578,1234579,1234589,1234678,1234679,1234689,1234789,1235678,1235679,1235689,1235789,1236789,1245678,1245679,1245689,1245789,1246789,1256789,1345678,1345679,1345689,1345789,1346789,1356789,1456789,2345678,2345679,2345689,2345789,2346789,2356789,2456789,3456789,12345678,12345679,12345689,12345789,12346789,12356789,12456789,13456789,23456789,123456789 the output for "ABCDEF": A,B,C,D,E,F,AB,AC,AD,AE,AF,BC,BD,BE,BF,CD,CE,CF,DE,DF,EF,ABC,ABD,ABE,ABF,ACD,ACE,ACF,ADE,ADF,AEF,BCD,BCE,BCF,BDE,BDF,BEF,CDE,CDF,CEF,DEF,ABCD,ABCE,ABCF,ABDE,ABDF,ABEF,ACDE,ACDF,ACEF,ADEF,BCDE,BCDF,BCEF,BDEF,CDEF,ABCDE,ABCDF,ABCEF,ABDEF,ACDEF,BCDEF,ABCDEF
Combinations, or k-combinations, are the unordered sets of k elements chosen from a set of size n. Source: http://www.martinbroadhurst.com/combinations.html This is the code: unsigned int next_combination(unsigned int *ar, size_t n, unsigned int k) { unsigned int finished = 0; unsigned int changed = 0; unsigned int i; if (k > 0) { for (i = k - 1; !finished && !changed; i--) { if (ar[i] < (n - 1) - (k - 1) + i) { /* Increment this element */ ar[i]++; if (i < k - 1) { /* Turn the elements after it into a linear sequence */ unsigned int j; for (j = i + 1; j < k; j++) { ar[j] = ar[j - 1] + 1; } } changed = 1; } finished = i == 0; } if (!changed) { /* Reset to first combination */ for (i = 0; i < k; i++) { ar[i] = i; } } } return changed; }
How to find top 6 elements in an array in C
I am trying to find top 6 elements from an array with their ordering number. int x=0; for (int k = 0; k < 6; k++) // { for (i = 1; i <= 90; i++) { if (sorted[k] < holder[i] && i >= x) { sorted[k] = holder[i]; x = i; // } } } But this does not work. I want it to give me output like 43->7 15 ->3 etc..
Haven't written C in a while, but here is a simple solution that modifies the array in place and uses selection sort to select the k highest numbers in the array and moves them to the front. It keeps an array of indices that correspond to where the number originally was and applies the same swaps to it. #include <stdio.h> #define ELEMENTS 10 void main(void) { // example input for execution int numbers[10] = {9,4,5,1,8,2,3,6,0,7}; // tracks ordering of indices int indexes[10] = {0,1,2,3,4,5,6,7,8,9}; int k = 6; int i, j; int max, temp; // Partial selection sort, move k max elements to front for (i = 0; i < k; i++) { max = i; // Find next max index for (j = i+1; j < ELEMENTS; j++) { if (numbers[j] > numbers[max]) { max = j; } } // Swap numbers in input array temp = numbers[i]; numbers[i] = numbers[max]; numbers[max] = temp; // Swap indexes in tracking array temp = indexes[i]; indexes[i] = indexes[max]; indexes[max] = temp; } for (i = 0; i < k; i++) { printf("%d -> %d\n", indexes[i], numbers[i]); } } And the output: 0 -> 9 4 -> 8 9 -> 7 7 -> 6 2 -> 5 1 -> 4
Here's the answer I have for you. I would love some constructive criticism on it from anyone who can provide some. #include <stdio.h> #include <stdlib.h> int main() { int numbers[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; int *ptrNumbers[10]; int i=0; for(; i < 10; i++){ ptrNumbers[i] = &numbers[i]; // assign the addresses } int topSix[6]; int topSixIndex=0; for(; topSixIndex < 6; topSixIndex++){ int **best = NULL; // Pointer to the pointer to the value. int checkIndex=0; for(; checkIndex < 10; checkIndex++){ if(ptrNumbers[checkIndex] != NULL){ if(!best){ /* best is not yet defined */ best = &ptrNumbers[checkIndex]; // best now points to the pointer for numbers[checkIndex] }else if(*ptrNumbers[checkIndex] > **best){ // this else if statement could be attached to the main if as // an or condition, but I've separated it for readability. best = &ptrNumbers[checkIndex]; // best now points to the pointer for numbers[checkIndex] } } } // assign the topSix position and flag the ptrNumbers topSix[topSixIndex] = **best; *best = NULL; } // now we'll print the numbers for(topSixIndex = 0; topSixIndex < 6; topSixIndex++){ printf("%d\n", topSix[topSixIndex]); } return 0; } Essentially the program works like this: Given an array of ten numbers, a second array is constructed to house pointers to those 10 numbers. A third array is then constructed to house the values of the top 6 numbers. A for loop is then initialized to loop 6 times to find the highest unrecorded value. When the highest value is found by looping the pointer array, the value is assigned to the next index of the top six array. Once that value is added, the pointer array's index that points to the top six value is then assigned to NULL. This acts as a flag insuring that the value will not be added again. Finally, all numbers are printed out. After running this code, the output I received was: 9 8 7 6 5 4 Edit: as a note, the ordering number's can be stored in a second array. You would simply need to track the checkIndex of the highest value and then assign it to a second array which contained the index values.
maybe you aren't looking for a code-only answer, but this will work: #include <limits.h> #include <stdlib.h> #include <string.h> #include <stdio.h> // return index of max element int max_index( int* vec, int sz ) { int idx, max, i; if(!sz) return -1; idx = 0; max = vec[0]; for(i=1; i<sz; ++i) { if( vec[i] > max ) { max = vec[i]; idx = i; } } return idx; } // return indexes of N top elements void top( int* vec, int sz, int* out_vec, int N ) { int i, *tmp, idx; tmp = (int*) malloc( sz*sizeof(int) ); memcpy( tmp, vec, sz*sizeof(int) ); for(i=0; i<N; ++i ) { idx = max_index(tmp,sz); out_vec[i]=idx; tmp[idx] = INT_MIN; } free(tmp); } see it live here
Make an array of struct that contain data and index, then sort it and pick up first or last 6 elements to output.
Say that you are given an array numbers. Then create an array indexes with the same size as numbers in such a way that its values are equal to their indexes. Here is an illustration: numbers = [ 1, 7, 3, 9, 2, 0 ] indexes = [ 0, 1, 2, 3, 4, 5 ] Sort numbers in descending order, performing the same operations on indexes. In the end, you should end up with something like this: numbers = [ 9, 7, 3, 2, 1, 0 ] indexes = [ 3, 1, 2, 4, 0, 5 ] Finally, all you need to do is work with the first six elements of these arrays. #include <stdio.h> #define TRUE 1 #define FALSE 0 int contains(int array[], int array_size, int value) { int i; for (i = 0; i < array_size; i++) { if (array[i] == value) { return TRUE; } } return FALSE; } int main() { int numbers[] = { 1, 7, 3, 9, 2, 0 }; int indexes[] = { 0, 1, 2, 3, 4, 5 }; int numbers_size = 6; int largest[] = { -1, -1, -1, -1, -1, -1 }; int largest_index = 0; int i; for (i = 0; i < 6; i++) { int j; int max_index = -1; int max = -2147483648; for (j = 0; j < numbers_size; j++) { if (numbers[j] >= max && contains(largest, numbers_size, j) == FALSE) { max_index = j; max = numbers[max_index]; } } largest[largest_index++] = max_index; } for (i = 0; i < 6; ++i) { printf("%d->%d\n", largest[i], numbers[largest[i]]); } return 0; }
You probably should use bubblesort (and keep a function holding all the original indexes) and then just make it show the 6 first number of both arrays (from the indexes array and from the array you sorted itself)