C Programming

It means "see you" (see you later)

#include<stdio.h>

#include<conio.h>

void main()

{

int a[10],i,j,k;

int count=1,num[10],pos=0;

clrscr();

printf("Enter the Array Element ");

for(i=0;i<10;i++)

{

scanf("%d",&a[i]) ;

}//close the for loop

for(i=0;i<10;i++)

{

count=1,pos++;

for(j=0;j<10;j++)

{

if(a[i]==a[j])

{

for(k=j;k<10;j++)

a[k]=a[k+1]

}//close the if

count++;

}//close the for loop

num[pos] = count;

}//close the for loop

for(i=0;i<pos;i++)

printf("Repeted Number of IN Arrary %d",num[i]);

}//close the main

PHP and C are two different programming languages that cannot directly interact with eachother. You can have a program made with C call a PHP script, using its output (an indirect interaction), but there's no way to "embed" PHP into C code.

There is no language limit to "How many dimensions can an array be created in c?". The limit will depend on available memory.

interpreter

#include<stdio.h>

#include<conio.h>

void main()

{

char b=0;

float a;

clrscr();

a=1.234;

printf("\n%d%d%d%d%.3f",b,b,b,b,a);

getch();

}

Platform-dependent. If you have an OS on your computer, then most likely you cannot access hardware directly from userland programs.

Decimal numbers are real numbers. In C and C++ we use the float, double and long double data types to represent real numbers.

The C language provides many basic types. Most of them are formed from one of the four basic arithmetic type specifies in C (char, int, float and double), and optional specifies (signed, unsigned, short, long). Functions in computer programming and spreadsheets are very similar to those in math.

A compiler converts a program in one programming language into a program in another programming language. Often the conversion is into a language that can be understood directly by the hardware.

The default is to pass by value.

English, or more precisely American.

The names given to these functions are implementation-specific. Below are some common examples.

Adding an element to the end: enqueue, push, add

Removing an element form the top: dequeue, pop, remove

#include<stdio.h>

#include<math.h>

float detrm(float[][],float);

void cofact(float[][],float);

void trans(float[][],float[][],float);

main()

{

float a[25][25],k,d;

int i,j;

printf("ENTER THE ORDER OF THE MATRIX:\n");

scanf("%f",&k);

printf("ENTER THE ELEMENTS OF THE MATRIX:\n");

for(i=0;i<k;i++)

{

for(j=0;j<k;j++)

{

scanf("%f",&a[i][j]);

}

}

d=detrm(a,k);

printf("THE DETERMINANT IS=%f",d);

if(d==0)

printf("\nMATRIX IS NOT INVERSIBLE\n");

else

cofact(a,k);

}

/******************FUNCTION TO FIND THE DETERMINANT OF THE MATRIX************************/

float detrm(float a[25][25],float k)

{

float s=1,det=0,b[25][25];

int i,j,m,n,c;

if(k==1)

{

return(a[0][0]);

}

else

{

det=0;

for(c=0;c<k;c++)

{

m=0;

n=0;

for(i=0;i<k;i++)

{

for(j=0;j<k;j++)

{

b[i][j]=0;

if(i!=0&&j!=c)

{

b[m][n]=a[i][j];

if(n<(k-2))

n++;

else

{

n=0;

m++;

}

}

}

}

det=det+s*(a[0][c]*detrm(b,k-1));

s=-1*s;

}

}

return(det);

}

/*******************FUNCTION TO FIND COFACTOR*********************************/

void cofact(float num[25][25],float f)

{

float b[25][25],fac[25][25];

int p,q,m,n,i,j;

for(q=0;q<f;q++)

{

for(p=0;p<f;p++)

{

m=0;

n=0;

for(i=0;i<f;i++)

{

for(j=0;j<f;j++)

{

b[i][j]=0;

if(i!=q&&j!=p)

{

b[m][n]=num[i][j];

if(n<(f-2))

n++;

else

{

n=0;

m++;

}

}

}

}

fac[q][p]=pow(-1,q+p)*detrm(b,f-1);

}

}

trans(num,fac,f);

}

/*************FUNCTION TO FIND TRANSPOSE AND INVERSE OF A MATRIX**************************/

void trans(float num[25][25],float fac[25][25],float r)

{

int i,j;

float b[25][25],inv[25][25],d;

for(i=0;i<r;i++)

{

for(j=0;j<r;j++)

{

b[i][j]=fac[j][i];

}

}

d=detrm(num,r);

inv[i][j]=0;

for(i=0;i<r;i++)

{

for(j=0;j<r;j++)

{

inv[i][j]=b[i][j]/d;

}

}

printf("\nTHE INVERSE OF THE MATRIX:\n");

for(i=0;i<r;i++)

{

for(j=0;j<r;j++)

{

printf("\t%f",inv[i][j]);

}

printf("\n");

}

}

ALTERNATIVE CODE:

#include<iostream.h>

#include<stdio.h>

#include<conio.h>

#include<process.h>

#include<math.h>

// Written by Ran

// There have been enough comments to help the reader easily understand this program

// Helpfulness of COMMENTS in this program and Pre-requisites:-

// a. However it's assumed that the reader is familiar with the basics of C++

// b. It is also assumed that the reader knows the basic mathematics involving matrices.

// c. Since this program focusses on how to find inverse of a matrix, the comments

// in the program are sufficient for understanding this.

// It is assumed that the reader is familiar with basics of matrices in C++ (like input, display,

// addition,transpose,etc. of matrices)

// The comments in this program aim to explain the reader how to find inverse

// d. Hence through comments, the reader will also be taught how to find determinant,

// adjoint, cofactor,etc. However as said in the previous lines, there won't be comments

// for explaining basics like input,display,etc of a matrix using C++.

// NOTES:

// 1. float datatype has been used for matrix, determinant.

// 2. To have consistency between mathematics and C++, this program considers a[1][1] as the first element

// i.e row and column indices begin with 1 same as mathematics.

// Define a structure matrix with a matrix (2D array of type float) and size n

// Declare the objects of this structure used in this program

struct matrix

{

float a[25][25];

int n;

}obj,c_obj,trans_obj,obj_cof,obj_adj,obj_inv;

// Prototypes of the functions used in this program

void input(matrix&);

void display(matrix&);

matrix reduced(matrix &, int ,int );

float determinant(matrix);

float cofactor(matrix,int,int);

matrix transpose(matrix);

matrix adjoint(matrix);

matrix inverse(matrix obj);

// Begining of Main function

int main()

{

// Getting dimensions input by the user

int r,c;

again:

cout<<"Enter the order of the matrix: "<<endl;

cout<<"Enter Row dimension: ";

cin>>r;

cout<<"Enter Column dimension: ";

cin>>c;

// Check dimensions for square matrix so that inverse can be found

// If user enters different dimensions for row and column, ask to re-enter or quit program

if(r!=c)

{

char ans;

cout<<"Inverse can be found out only for a square matrix. Enter same dimension for row and column. Do you want to enter the dimensions again? Press Y for yes"<<endl;

cin>>ans;

if(ans=='y')

goto again;

else

cout<<"Program exit";

getch();

exit(0);

}

// If it's a square matrix, proceed

else if(r==c)

{obj.n=r;}

cout<<endl;

input(obj); // call input function to input the matrix elements from the user

display(obj); // display the matrix got as input now

// Following lines were used to test parts/sections/segments of the code and hence commented

/* char ans2;

cout<<"do u want to check reduce matrix? Press y to check reduce matrix and press any char to skip this"<<endl;

cin>>ans2;

if(ans2=='y')

{

int i,j;

cout<<"Enter row i and col j to get reduced matrix"<<endl;

cin>>i>>j;

// i=i-1;

// j=j-1;

c_obj=reduced(obj,i,j);

char ans1;

cout<<"Do you want to display the reduced matrix? If yes, Press y "<<endl;

cin>>ans1;

if(ans1=='y')

{

cout<<"Displaying reduced matrix..."<<endl;

display(c_obj);

}

}*/

//Find Determinant

cout<<"Finding determinant......"<<endl;

cout<<"The determinant is"<<determinant(obj)<<endl;

//Find Cofactor if user wishes to

char ans3;

cout<<"Do you want to find cofactor? Press y if yes"<<endl;

cin>>ans3;

while(ans3=='y')

{

int i,j;

cout<<"Finding cofactor. Enter row and column"<<endl;

cin>>i>>j;

cout<<"Cofactor of a["<<i<<"]["<<j<<"] is "<<cofactor(obj,i,j)<<endl;

cout<<"want of find cofactor of another element? Press y for yes"<<endl;

cin>>ans3;

}

// Following lines were to meant to test ONLY the transpose function and hence commented

/* cout<<"Printing Transpose of the matrix "<<endl;

matrix trans1;

trans1=transpose(obj);

display(trans1);

*/

// Find Inverse

cout<<"\n\n\n Finding Inverse. . .\n\n";

matrix obj_inv2;

obj_inv2=inverse(obj);

display(obj_inv2); // Display the matrix inverse

getch();

return 0;

}

void input(matrix &obj)

{

// This function gets elements of a matrix input by the user

// Parameter is the structure object obj (used throughout the program)

// Parameter is "passed by reference" so as to reflect the changes made by this function, to other functions that call it

cout<<"Enter the matrix "<<endl;

for (int i=1;i<=obj.n;i++)

{

for (int j=1;j<=obj.n;j++)

{

cout<<"Enter the element a["<<i<<"]["<<j<<"] : ";

cout<<endl;

cin>>obj.a[i][j];

}

}

}

void display(matrix &obj)

{

// This function displays elements of a matrix passed to it as a parameter

// Parameter is the structure object obj (used throughout the program)

// Parameter is "passed by reference" but may be "passed by value" also.

if(obj.n==0)

return;

else{

cout<<"The matrix is: "<<endl;

for (int i=1;i<=obj.n;i++)

{

for (int j=1;j<=obj.n;j++)

{

cout<<obj.a[i][j]<<" ";

}

cout<<endl;

}

}}

matrix reduced(matrix &obj, int i,int j)

{

// This function reduces the matrix passed as input to it

// The 'reduction' requirement is like this:

// Eliminate the row i and column j from the given matrix to get the reduced matrix

// This is done by the following logic:

// a is given matrix. c_obj is desired reduced matrix

// i. Using two for loops (iterating with p and q here) as usual, we scan the given matrix.

// row and col represent the current location pointer of row and column of the required reduced matrix.

// ii. All elements from given matrix are copied to reduced matrix except for those corresponding to

// row i and column j

// iii. The reduced matrix has its dimensions one less than that of given matrix

int row=1,col=1;

for(int p=1;p<=obj.n;p++) // outer loop traverses through rows as usual

{

for(int q=1;q<=obj.n;q++) // inner loop traverses through columns as usual

{

if((p!=i)&&(q!=j)) // Skip the elements corresponding to row i OR column j of the given matrix

{

c_obj.a[row][col]=obj.a[p][q];

col=col+1;

}

if(col>=obj.n) // When column 'col' of reduced matrix reaches (or exceeds n), reset it to 1

{ // and increment 'row'. This means current row of reduced matrix got filled and

// we need to begin filling a new row.

col=1;

row=row+1;

if (row>=obj.n) //This represents the case when both 'col' and 'row of reduce matrix reach (or

// exceed) n. This means the reduced matrix has been filled up.Break out of the loops.

break;

}

}

}

c_obj.n=obj.n-1; // Fix the dimension of the reduced matrix one less than the given input matrix

return c_obj; // Return the reduced matrix to the calling function.

}

float determinant(matrix obj)

{

// This function is called recursively until we get dimension = 1 where the only element in the matrix gets returned.

float det=0;

if(obj.n==1)

{return obj.a[1][1];

}

else

{

for(int scan=1;scan<=obj.n;scan++)//Fix the first row and vary the column in this row using for loop iteration variable 'scan'

{

det=det+obj.a[1][scan]*int(pow(-1,(1+scan)))*determinant(reduced(obj,1,scan));

// det is calculated to be the sum of the following

// i. prev value stored in det.

// ii. current element in the first row (i.e. a[1][scan]) MULTIPLIED by -1^(i+j) [i is 1 for 1st row and j is nothing but scan here MULTIPLIED by the reduced matrix corresponding to this i (1) and j (scan)

// PLEASE UNDERSTAND BY COMPARING THIS WITH THE MATHEMATICAL WAY OF CALCULATING DETERMINANT

// - It's computed in a similar way here.

}

return det;

}

}

float cofactor(matrix obj,int i,int j)

{

// The computation done here is like this:

// If the matrix (passed as paramenter) has dimension = 1, return the only element as cofactor

// Else, return determinant of the reduced matrix corresponding to i and j passed with a

// multiplication factor -1^(i+j)

float cofact;

if(obj.n==1)

{

return obj.a[1][1];

}

else

{

cofact=int(pow(-1,(i+j)))*determinant(reduced(obj,i,j));

}

return cofact;

}

matrix transpose(matrix obj)

{

// Transpose matrix is the given matrix with its rows and columns interchanged.

// Just invert the elements during storing when scanning through the for loops

// trans_obj is the transposed matrix, returned by the function.

// obj is the input matrix passed to this function.

trans_obj.n=obj.n;

for(int i=1;i<=obj.n;i++)

{

for(int j=1;j<=obj.n;j++)

{

trans_obj.a[i][j]=obj.a[j][i];

}

}

return trans_obj;

}

matrix adjoint(matrix obj)

{

// obj_adj is adjoint matrix and obj_cof is cofactor matrix

// both have dimensions n

// Cofactor matrix of a given matrix is a matrix whose elements are the cofactors of the respective

// elements of the given matrix

// Adjoint matrix is transpose of cofactor matrix. Return this

obj_adj.n=obj.n;

obj_cof.n=obj.n;

for(int i=1;i<=obj.n;i++)

{

for(int j=1;j<=obj.n;j++)

{

obj_cof.a[i][j]=cofactor(obj,i,j);

}

}

obj_adj=transpose(obj_cof);

return obj_adj;

}

matrix inverse(matrix obj)

{

// Formula : Inverse of a matrix is = adj(matrix)/its determinant

float d=determinant(obj); // First find determinant of the given matrix

matrix obj_null;

obj_null.n=0;

// Display error message if determinant is 0

if(d==0)

{

cout<<"Inverse can be found only if the determninant of the matrix is non-zero"<<endl;

return obj_null;

}

// Determinant is non-zero - Proceed finding inverse using the above formula

else

{

matrix obj_adj1=adjoint(obj);

obj_adj1.n=obj.n;

obj_inv.n=obj.n;

for(int i=1;i<=obj.n;i++)

{

for(int j=1;j<=obj.n;j++)

{

obj_inv.a[i][j]=(obj_adj1.a[i][j])/d;

}

}

return obj_inv;

}

}

A while loop evaluates the conditional expression at the start of each iteration, whereas a do..while loop evaluates the conditional expression at the end of each iteration. Thus the do..while loop always executes at least one iteration.

n/2 times (n + 1)

/* INPUT: Holy Home

* OUTPUT:H

* ------------ o

* --------------l

* ---------------y

* ---------------- _______________//The '-' are spaces

* ------------------H

* --------------------o

* ---------------------m

* -----------------------e

*

*/

import java.io.*;

class StyleString

{

protected static void main()throws IOException

{

BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

System.out.print("Enter the String: ");

String s=in.readLine();

for(byte i=0;i<s.length();i++)

{

System.out.println();

for(byte j=0;j<i;j++)

System.out.print(' ');

System.out.print(s.charAt(i));

}

}

}

The declaration int (*f) (int*); declares a function pointer named f. The function pointer can be assigned the address of any function that accepts a pointer to int and returns an int. Function pointers can be used to pass functions to functions. Normally we use typedefs to simplify the notation of function pointers:

typedef int (*f) (int*);

int x (int*);

int y (int*);

f fp; // declare a function pointer of type f

int z = 42;

fp = x; // point to the x function

fp (&z); // invoke function via pointer

fp = y; // point to the y function

fp (&z); // invoke function via pointer.

A typical usage of function pointers is to provide a predicate for a comparison sort algorithm. This makes it possible for the same sorting algorithm to compare objects using different predicates. For example:

typedef bool (*pred) (int, int); // function pointer type named pred

void sort (int a[], size_t len, pred func) {

// simple shell sort

for(int i=len/2; i>0; i=i/2)

{

for(int j=i; j<len; j++)

{

for(k=j-i; k>=0; k=k-i)

{

if( !func (a[k+i], a[k]) // invoke the predicate function

{

swap (a[k], a[k+i]);

}

}

}

}

}

// Declare predicates...

bool less_than (int a, int b) { return a<b);

bool greater_than (int a, int b) { return a>b; }

int main () {

int x[] = {3,5,2,4,1};

sort (x, 5, less_than); // sort array of 5 elements in ascending order

sort (x, 5, greater_than); // sort array of 5 elements in descending order

return 0;

}

If you are speaking of while loops, this might be the answer for you.

Example 1:

for (i = 0; i < 100; i++)

{

}

Example 2:

do

{

i++;

} while (i < 100);

or even

Example 3:

while (i < 100)

{

i++;

}

This finalization of loops can be done with many conditions. These examples contain only counter. There are many other ways to make an infinite loop finite.

A 'goto' statement immediately moves the execution of code to another part of the program. This makes the code difficult to follow and to debug. It is better practice to use If-then-else constructs to structure the program code.

unix.

'argc' and 'argv' in this line:

int main (int argc, char **argv)

Please refer to Wikipedia where there is a full C example to do specifically this. I imagine whoever had the homework assignment before you posted their answer there.