Print elements after place in array in c - c

So I tried to print elements of array after some point or place
but its print me another number of garbage. The code need to print 7,8,9,5.
I'm sure that the problem is in the line :
for (arr=x+1; arr < arr+ n; arr++)
but I don't understand what to write instead this line.
Please help me and use * or & instead [](use pointers). thanks!
#include <stdio.h>
#include <stdlib.h>
void printAfterX(int* arr, int n, int* x);
int main(void)
{
int arr[] = { 4, 8, 6, 2, 1, 3, 5, 7, 8, 9, 5 };
printAfterX(arr, 11, arr + 6);
system("PAUSE");
return 0;
}
void printAfterX(int* arr, int n, int* x)
{
if (n >= arr)
{
printf("not found");
}
else
{
for (arr=x+1; arr < arr+ n; arr++)
{
printf("%d ",*arr);
}
}
}

Why do you need to mix pointers and indices? You are right, in the line for (arr=x+1; arr < arr+n; arr++) there is a problem, because arr < arr + n is always true for positive n. So, this loop will never end.
Also it is not clear what does if (n >= arr) mean. Here you compare number of elements in the array and pointer on this array. It is useless. It seems that you need to compare x and arr.
I'd recommend you to use index of element to simplify your code. Try this:
void printAfterX(int* arr, int n, int x)
{
if (x < 0 || x+1 >= n)
{
printf("not found");
}
else
{
for (int i = x+1; i < n; i++)
{
printf("%d ", arr[i]);
}
}
}
And to call this function you need to change third parameter:
printAfterX(arr, 11, 6);
Also it is better to avoid using of system("pause") - read here: system("pause"); - Why is it wrong?
Update:
Ok, if you need to use pointers, try this:
void printAfterX(int* arr, int n, int* x)
{
if (x < arr || x+1 > arr+n)
{
printf("not found");
}
else
{
for (x = x+1; x < arr + n; x++)
{
printf("%d ", *x);
}
}
}

It is obvious that arr < arr + n always holds true unless it has an overflow, so the loop won't stop before that happens.
Furthermore, by writing n >= arr, you compare an int to an int *, which definitely make no sense. To check the array bound, you should also check whether it's less than the lower bound.
Finally, I think it's better to use a simple while loop.
Here is the refined code:
#include <stdio.h>
#include <stdlib.h>
void printAfterX(int *arr, int n, int *x);
int main(void)
{
int arr[] = { 4, 8, 6, 2, 1, 3, 5, 7, 8, 9, 5 };
printAfterX(arr, 11, arr + 6);
getchar();
return 0;
}
void printAfterX(int *arr, int n, int *x)
{
if (x < arr || x >= arr + n)
{
printf("No such element");
}
while(x < arr + n)
{
printf("%d ", *x);
x++;
}
}

The line for (arr=x+1; arr < arr+ n; arr++) is an infinite loop as arr < arr+ n is always true.
Also in line if (n >= arr) you are comparing a int with a pointer,which is not meaningful.
Modify your function like this:
void printAfterX(int* arr, int n, int* x)
{
if (n <= x-arr) //checking it doesn't exceeds the size
{
printf("not found");
}
else
{
for (x++; x < arr+ n; x++)
{
printf("%d ",*x);
}
}
}

You have to pass the number of elements as a parameter to the function to know when you have reached the end of the array.
You also can't compare a variable of type int to varibale of type int *.Try this version:
#include <stdio.h>
#include <stdlib.h>
void printAfterX(int* arr, size_t size, size_t offset);
int main(void)
{
int arr[] = { 4, 8, 6, 2, 1, 3, 5, 7, 8, 9, 5 };
printAfterX(arr, 11, 7);
system("PAUSE");
return 0;
}
void printAfterX(int* arr, size_t size, size_t offset)
{
if (offset >= size)
{
printf("not found");
return;
}
else
{
while(offset < size)
{
printf("%d ", *(arr + offset));
offset++;
}
}
}

Try it:
#include <stdio.h>
#include <stdlib.h>
void printAfterX(int[], int, int);
int main(void)
{
int arr[] = { 4, 8, 6, 2, 1, 3, 5, 7, 8, 9, 5 };
printAfterX(arr, 11, 6);
system("PAUSE");
return 0;
}
void printAfterX(int arr[], int n, int x)
{
if (n <= arr[x])
{
printf("not found");
}
else
{
for (i=x+1; i < n; i++)
{
printf("%d ",arr[i]);
}
}
}

Related

Remove negative numbers and sort an array

Good day everyone,
my task is to remove all negative numbers from an array, and shorten it (return the new length as the amount of positive numbers). I tried doing that by BubbleSort all negative number to the right, and new length would be (old length - number of swap). My code simply freezes up the system.
I would be grateful if you guys could help.
void swap(int *p, int *q) {
int h = *p;
*p = *q;
*q = h;
}
int remove_negatives(int *array, int length) {
int *a;
int n = length;
a = &array[n - 1];
for (int i = 0; i <= n - 1; i++) {
while (array < a) {
if (*array < 0) {
swap(a, array);
a--;
array++;
length--;
}
}
}
printialn(array, n);
return length;
};
int main(void) {
int a[] = {-1, 2, 4, -8, 3, 7, -8, 9, 3};
int l = sizeof(a) / sizeof(a[0]);
printiln(remove_negatives(a, l));
return 0;
}
The while loop never stops, that's probably the reason your code freezes.
Your code only changes the address when the if statement is true. Which the array in your main() will stuck on the second (a[1]) element. So if we change change the address when the if statement is false...
#include<stdio.h>
#include<stdlib.h>
void swap(int *p, int *q) {
int h = *p;
*p = *q;
*q = h;
}
int remove_negatives(int *array, int length) {
int *a, *head;
int n = length;
head = array;
a = &array[n - 1];
for (int i = 0; i <= n - 1; i++) {
while (array < a) {
if (*array >= 0) {
array++;
continue;
}
swap(a, array);
a--;
array++;
length--;
}
}
for (int i=0; i<length; i++) {
printf("%d ", *head);
head++;
}
puts("");
return length;
}
int main(void) {
int a[] = {-1, 2, 4, -8, 3, 7, -8, 9, 3};
int l = sizeof(a) / sizeof(a[0]);
remove_negatives(a, l);
return 0;
}
Now the while loop works, buts as #wovano said, the answer is still wrong. Your code isn't exactly a "bubble sort". you swap all the negative number to the end of the array and didn't actually sort the array.
So, let's start from the beginning.
To simplify the process, let bubble sort first, and then find the new array length.
#include<stdio.h>
#include<stdlib.h>
void swap(int *p, int *q) {
int h = *p;
*p = *q;
*q = h;
}
int bubble_sort(int *array, int length) {
int i, j;
// Bubble sort
for (i=0; i<length-1; i++) {
for (j=i+1; j<length; j++) {
if (array[i]<array[j]) swap(&array[i], &array[j]);
}
}
// Find new array length
for (i=length-1; i>=0; i--) {
if (array[i]>=0) break;
length--;
}
return length;
}
int main(void) {
int a[] = {-1, 2, 4, -8, 3, 7, -8, 9, 3};
int l = sizeof(a) / sizeof(a[0]);
l = bubble_sort(a, l);
for (int i=0; i<l; i++) printf("%d ", a[i]);
puts("");
return 0;
}

Find max, min and sum of an array using function

I want to create a programm to find maximum, minimum and summation for a given array, but when I take my code to compiler, it returned expressed expression before 'int' and too few arguments to all the functions.
And here is my code, please tell me why it doesn't work.
#include <stdio.h>
#include <stdlib.h>
void print_array(int array[], int len) {
// print array on screen
int b;
printf("Array: ");
for (b = 0; b < len - 1; b++) {
printf("%d, ", array[b]);
}
if (b >= len - 1) {
printf("%d\n", array[b]);
}
}
// function
int min(int *x, int len) {
int mintemp = x[0], i;
for (i = 1;i < len;i++) {
if(x[i] < mintemp) {
mintemp = x[i];
}
}
return mintemp;
}
int max(int *y, int len) {
int maxtemp = y[0], j;
for (j = 1;j < len;j++) {
if(y[j] > maxtemp) {
maxtemp = y[j];
}
}
return maxtemp;
}
int sum(int *z, int len) {
int sumtemp = 0, k;
for (k = 0;k < len;k++) {
sumtemp = sumtemp + z[k];
}
return sumtemp;
}
int main() {
int array[] = {3, 9, 1, 2, 5, 8, 7, 6, 4, 10, 11};
int len = 11;
print_array(array, len);
// print other elements on screen
printf("Maximum: %d\n", max(int *x, int len));
printf("Minimum: %d\n", min(int *y, int len));
printf("Summation: %d\n", sum(int *z, int len));
return 0;
}
The problem was with calling the functions. Function call in C is like this
function_name(argument 1, argument 2, argument 3, ......, argument n);
There is no need to specifying the data type along the parameters in the call like you were doing in your code.
Also you were passing pointers x, y and z that do not point to your array.
I have corrected the code as shown below.
int main() {
int array[] = {3, 9, 1, 2, 5, 8, 7, 6, 4, 10, 11};
int len = 11;
print_array(array, len);
// print other elements on screen
printf("Maximum: %d\n", max(array, len)); // pass array and len
printf("Minimum: %d\n", min(array, len));
printf("Summation: %d\n", sum(array, len));
return 0;
}
If you want to pass the array to functions via pointers you can do it like this.
int main() {
int array[] = {3, 9, 1, 2, 5, 8, 7, 6, 4, 10, 11};
int len = 11;
int *x = array;
int *y = array;
int *z = array;
print_array(array, len);
// print other elements on screen
printf("Maximum: %d\n", max(x, len));
printf("Minimum: %d\n", min(y, len));
printf("Summation: %d\n", sum(z, len));
return 0;
}
Also there is no need to declare 3 different pointers and pass it to the functions, you can declare just one and reuse it with subsequent calls.
Hope this helps.!!

Find how many times the largest digit appears in an array

I have no idea what's wrong with the function goes by the name "int Count_largest_even". It's supposed to take the largest digit found in the given array (by the function "int find") and find how many times the digit appears in the array.
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int Count_largest_even(int size, int *array, int large);
void ArrayPrint(int a[], int size);
int find(int array[], int size);
int arr1[16] = { 2, 22, 1, 3, 24, 94, 93, 12, 12, 66666, 21, 24, 8888, 21, 2, 33 };
int main() {
int mount;
int even;
ArrayPrint(arr1,16);
even = find(arr1, 16);
mount = Count_largest_even(16, arr1, even);
printf("\n The biggest even digit is : %d\n %d", even,mount);
system("pause");
return 0;
}
int find(int array[], int size){
int i = 0, digit, edigit = 0;
for (i = 0; i<size; i++){
while (array[i]!=0)
{
digit = abs(array[i] % 10);
if (digit > edigit)//checking condition for large
{
if (digit % 2 == 0)
{
edigit = digit;
}
}
array[i] = array[i] / 10;
}
}
return edigit;
}
void ArrayPrint(int a[], int size)
{
int i;
for (i = 0; i<size; i++){
printf("%d\n", a[i]);
}
}
int Count_largest_even(int size, int *array, int large)
{
int i;
int count = 0, digit;
for (i = 0; i < size; i++){
while ((array[i]!=0))
{
digit = abs(array[i] % 10);
if (digit == large)
{
count++;
}
array[i] = array[i] / 10;
}
}
return count;
}
As Ian Abbott said, you should not modify the array inside your loop.
But you can also do this in a single pass - some pseudo code:
int count = 0;
int largest_digit = 0;
for each digit:
if(digit > largest_digit) {
largest_digit = digit;
count = 1;
}
else if(digit == largest_digit)
count++;

Count the number of times a number appears in an array

I'm working on a small program that counts the number of times an integer appears in an array.
I managed to do this but there is one thing I can't overcome.
My code is:
#include <stdio.h>
int count_occur(int a[], int num_elements, int value);
void print_array(int a[], int num_elements);
void main(void)
{
int a[20] = {2, 5, 0, 5, 5, 66, 3, 78, -4, -56, 2, 66, -4, -4, 2, 0, 66, 17, 17, -4};
int num_occ, i;
printf("\nArray:\n");
print_array(a, 20);
for (i = 0; i<20; i++)
{
num_occ = count_occur(a, 20, a[i]);
printf("The value %d was found %d times.\n", a[i], num_occ);
}
}
int count_occur(int a[], int num_elements, int value)
/* checks array a for number of occurrances of value */
{
int i, count = 0;
for (i = 0; i<num_elements; i++)
{
if (a[i] == value)
{
++count; /* it was found */
}
}
return(count);
}
void print_array(int a[], int num_elements)
{
int i;
for (i = 0; i<num_elements; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
My output is :
Array:
2 5 0 5 5 66 3 78 -4 -56 2 66 -4 -4 2 0 66 17 17 -4
The value 2 was found 3 times.
The value 5 was found 3 times.
The value 0 was found 2 times.
The value 5 was found 3 times.
The value 5 was found 3 times.
The value 66 was found 3 times.
The value 3 was found 1 times.
The value 78 was found 1 times.
The value -4 was found 4 times.
The value -56 was found 1 times.
The value 2 was found 3 times.
The value 66 was found 3 times.
The value -4 was found 4 times.
The value -4 was found 4 times.
The value 2 was found 3 times.
The value 0 was found 2 times.
The value 66 was found 3 times.
The value 17 was found 2 times.
The value 17 was found 2 times.
The value -4 was found 4 times.
How can I avoid double lines in the output?
You can use a parallel array, this example uses char[20] in order to save some space:
#include <stdio.h>
int count_occur(int a[], char exists[], int num_elements, int value);
void print_array(int a[], int num_elements);
int main(void) /* int main(void), please */
{
int a[20] = {2, 5, 0, 5, 5, 66, 3, 78, -4, -56, 2, 66, -4, -4, 2, 0, 66, 17, 17, -4};
char exists[20] = {0}; /* initialize all elements to 0 */
int num_occ, i;
printf("\nArray:\n");
print_array(a, 20);
for (i = 0; i < 20; i++)
{
num_occ = count_occur(a, exists, 20, a[i]);
if (num_occ) {
exists[i] = 1; /* first time, set to 1 */
printf("The value %d was found %d times.\n", a[i], num_occ);
}
}
}
int count_occur(int a[], char exists[], int num_elements, int value)
/* checks array a for number of occurrances of value */
{
int i, count = 0;
for (i = 0; i < num_elements; i++)
{
if (a[i] == value)
{
if (exists[i] != 0) return 0;
++count; /* it was found */
}
}
return (count);
}
void print_array(int a[], int num_elements)
{
int i;
for (i = 0; i<num_elements; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
This method is faster, as it skips values already readed and starts iterating from i in count_ocurr:
#include <stdio.h>
int count_occur(int a[], char map[], int num_elements, int start);
void print_array(int a[], int num_elements);
int main(void)
{
int a[20] = {2, 5, 0, 5, 5, 66, 3, 78, -4, -56, 2, 66, -4, -4, 2, 0, 66, 17, 17, -4};
char map[20] = {0};
int num_occ, i;
printf("\nArray:\n");
print_array(a, 20);
for (i = 0; i < 20; i++)
{
if (map[i] == 0) {
num_occ = count_occur(a, map, 20, i);
printf("The value %d was found %d times.\n", a[i], num_occ);
}
}
}
int count_occur(int a[], char map[], int num_elements, int start)
/* checks array a for number of occurrances of value */
{
int i, count = 0, value = a[start];
for (i = start; i < num_elements; i++)
{
if (a[i] == value)
{
map[i] = 1;
++count; /* it was found */
}
}
return (count);
}
void print_array(int a[], int num_elements)
{
int i;
for (i = 0; i< num_elements; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
I would suggest only printing the statement if the current index is also the index of the first occurrence of the number in question.
Inside count_occur, you have the index of each match in i. If you pass in the i from main to count_occur, you can do something such as returning -1 if that value is greater than the i in count_occur. Then if you get that -1 in main, don't print.
In addition, your algorithm could be made faster. Instead of searching the array linearly every time, you can sort a copy of the array so that the search can be done efficiently. (Even if you use one array to index and the other to search, it'll be faster - and still return values in the same order.)
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
int count_occur(int a[], int num_elements, int value, bool selected[]);
void print_array(int a[], int num_elements);
int main(void){
int a[] = {2, 5, 0, 5, 5, 66, 3, 78, -4, -56, 2, 66, -4, -4, 2, 0, 66, 17, 17, -4};
int size = sizeof(a)/sizeof(*a);
bool ba[size];
memset(ba, 0, sizeof ba);
int num_occ, i;
printf("\nArray:\n");
print_array(a, size);
for (i = 0; i<size; i++){
if(ba[i] == true) continue;//skip already count
num_occ = count_occur(a, 20, a[i], ba);
printf("The value %d was found %d times.\n", a[i], num_occ);
}
}
int count_occur(int a[], int num_elements, int value, bool ba[]){
int i, count = 0;
for (i = 0; i<num_elements; i++){
if (a[i] == value){
ba[i] = true;
++count;
}
}
return count;
}
void print_array(int a[], int num_elements){
int i;
for (i = 0; i<num_elements; i++){
printf("%d ", a[i]);
}
printf("\n");
}
Little improvement
int count_occur(int a[], int num_elements, int index, bool selected[]);
num_occ = count_occur(a, 20, i, ba);
int count_occur(int a[], int num_elements, int index, bool ba[]){
int i, count = 0;
for (i = index; i<num_elements; i++){
if (a[i] == a[index]){
ba[i] = true;
++count;
}
}
return count;
}
#include<stdio.h>
#include<string.h>
int main()
{
int arr[] = {2, 5, 0, 5, 5, 66, 3, 78, -4, -56, 2, 66, -4, -4, 2, 0, 66, 17, 17, -4};
int arrSize = sizeof(arr)/sizeof(arr[0]);
int tracker[20];
int i,j,k=0,l=0,count,exists=0;
for (i=0;i<arrSize;i++)
printf("%d\t", arr[i]);
printf("\n");
memset(tracker, '$', 20);
for (i=0, j=i+1, count=1, l=0; i<arrSize; i++)
{
j=i+1;
count=1;
l=0;
while (l < arrSize)
{
if (arr[i] == tracker[l])
{
exists = 1;
break;
}
l++;
}
if (1 == exists)
{
exists = 0;
continue;
}
while (j < arrSize)
{
if (arr[i] == arr[j])
count++;
j++;
}
tracker[k] = arr[i];
k++;
printf("count of element %d is %d\n", arr[i], count);
}
}
very simple logic to count how many time a digit apper
#include<stdio.h>
int main()
{
int a,b,c,k[10];
int p[10]={0};
int bb[10]={0};
scanf("%d\n",&a);
for(b=0;b<a;b++)
{
scanf("%d",&k[b]);
}
for(b=a-1;b>0;b--)
{
for(c=b-1;c>=0;c--)
{
if((k[b]==k[c])&&(bb[c]==0))
{
p[b]=p[b]+1;
bb[c]=1;
}
}
}
for(c=0;c<a;c++)
{
if(p[c]!=0)
{
printf("%d is coming %d times\n",k[c],p[c]+1);
}
}
return 0;
}
In your function :
int count_occur(int a[], int num_elements, int value)
/* checks array a for number of occurrances of value */
{
int i, count = 0;
for (i = 0; i<num_elements; i++)
{
if (a[i] == value)
{
++count; /* it was found */
a[i] = INFINITY; // you can typedef INFINITY with some big number out of your bound
}
}
return(count);
}
And in main() you can edit for loop:
for (i = 0; i<20; i++)
{
if(a[i] != INFINITY)
{
num_occ = count_occur(a, 20, a[i]);
printf("The value %d was found %d times.\n", a[i], num_occ);
}
}
It is possible to solve with two arrays
#include <stdio.h>
int main() {
int array[12] = {1,2,2,5,2,5,7,6,2,4,2,4};
int array2[100] = {0};
int indicator = 1;
int i = 0,j;
int index = 0;
int number_count;
for(int i = 0; i<12;i++) {
indicator = 1;
for(j = i+1;j<12;j++) {
if(array[i] == array[j]){
indicator = -1;
break;
}
}
if(indicator == 1){
array2[index] = array[i];
index++;
}
}
for(int k = 0; array2[k]; k++) {
number_count = 0;
for(int m = 0; m<12;m++){
if(array2[k] == array[m]){
number_count++;
}
}
printf("%d was found %d times...\n",array2[k],number_count);
}
return 0;
}

C recursive permutations

i have been trying to complete figure out this part of my assignment to no avail for the past day, and require some help or guidance to help understand the problem.
so far i have this:
swap(int A, int B){
int temp;
temp = A;
A = B;
B = temp;
}
int max_array(int array[], int arraySize)
{
int i, max=-32000;
for (i=0; i<arraySize; i++)
{
if (array[i]>max)
{
max=array[i];
}
}
printf("%d \n Max array: ", max)
return(max);
}
int nextPermutation(int array[], int arraySize){
int i;
n = max_array(array, arraySize);
if (int i; n == array[i] && i > 1; i++){
swap(array[i], array[i-1]);
}
else if(int i; n == array[i]; i++){
}
}
void main(){
int intArray[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//int intArray[10] = {1, 10, 3, 9, 8, 6, 7, 2, 4, 5};
nextPermutation(intArray, 10);
int i = 0;
for(i = 0; i < 10; i++){
printf("%d ",intArray[i]);
}
}
But the question that i'm struggling to understand is
"If a1,...,an is an arbitrary permutation (where a1,...,an are the numbers 1, 2, …, n in a probably different order) then the “next” permutation is produced by the
following procedure:
(i) If the maximal element of the array (which is n) is not the first element of the
array, say n=ai , where i>1 , then to produce the "next" permutation you
need to swap ai and ai−1 .
(ii) If the maximal element of the array is in the first position, i.e. n=a1 , then to
produce the “next” permutation to the permutation (a1,...,an)
, first find the “next” permutation to the (n-1)-element permutation (a2,...,an
), and then append a1 to the end of thus obtained array of (n-1) elements."
so it needs to permutate every single possible combination with the array of 1,2,3,4,5,6,7,8,9,10 and then finish when it reaches this point "(n, …, 2, 1). And this is
the only permutation that does not have the "next" permutation to it."
And the function int 'nextPermutation(int array[], int arraySize){' needs to stay the same.
Any help or tips will be excellent!
There are some errors in your program,
swap() function will not affect the program as it doesn't use pass by reference.
max_array() should find the index of the maximum value, not the maximum value itself.
There is no recursion in your program as far as I can see.
main() should return int.
The program fragement given below might give you an idea,
int ct=-1,n=10,temp[10]={0,0,0,0,0,0,0,0,0,0};
int intArray[10]={1,2,3,4,5,6,7,8,9,10};
permute(int k)
{
int i;
temp[k]=++ct;
if(ct==n-1)
{
for(i=0;i<n;i++)
{
printf("%d",intArray[temp[i]]);
}
printf("\n");
}
for(i=0;i<n;i++)
{
if(temp[i]==0)
{
permute(i);
}
}
ct--;
temp[k]=0;
}
int main()
{
permute(0);
}
for swap sample
#include <stdio.h>
void swap(int* A, int* B){
int wk;
wk = *A;
*A = *B;
*B = wk;
}
int main(void){
int array[] = { 1,2,3 };
swap(&array[0], &array[2]);
printf("array[0]=%d, array[2]=%d\n", array[0], array[2]);
return 0;
}

Resources