C Programming

#include<iostream>

#include<fstream>

#include<string>

int main()

{

size_t count=0;

std::string vowels ("aeiouAEIOU");

std::ifstream ifs;

ifs.open ("test.txt", std::ios::in);

if (ifs.bad())

{

ifs.close();

std::cerr << "Invalid input file.\n" << std::endl;

return;

}

while (!ifs.eof())

{

char c = ifs.get();

if ((c>='a' && c<='z') (c>='A' && c<='Z'))

if (vowels.find (c) != vowels.npos)

++count;

}

ifs.close();

std::cout << "The file has " << count << " non-vowels.\n" << std::endl;

}

All built-in data types are not abstract data types.

A case sensitive language gives you more flexibility in naming variables. It also lets you use the same variable name more than once for different purposes by changing different letters to upper or lower case, each version being treated as a separate variable. In practice, this is not recommended as it can cause confusion in reading programs and keeping track of which variable has what purpose.

There is insufficient information in the question to answer it properly. What do you mean by "diamond". Are we talking Pascal's Triangle. Are we talking a diamond shaped field of stars? What? Please restate the question.

The algorithm will have both a constant time complexity and a constant space complexity: O(1)

// get input

char input[256];

gets(input);

// print one character on each line

int i;

for(i = 0; input[i] != '\0'; ++i) {

printf("%c\n", input[i]);

}

#include<stdio.h>

#include<conio.h>

#include<graphics.h>

#include<ctype.h>

#include<math.h>

#include<stdlib.h>

void draw(int x1,int y1,int x2,int y2);

void main()

{

int x1,y1,x2,y2;

int gdriver=DETECT,gmode,gerror;

initgraph(&gdriver,&gmode,"c:\\tc\\bgi:");

printf("\n Enter the x and y value for starting point:\n");

scanf("%d%d",&x1,&y1);

printf("\n Enter the x and y value for ending point:\n");

scanf("%d%d",&x2,&y2);

printf("\n The Line is shown below: \n");

draw(x1,y1,x2,y2);

getch();

}

void draw(int x1,int y1,int x2,int y2)

{

float x,y,xinc,yinc,dx,dy;

int k;

int step;

dx=x2-x1;

dy=y2-y1;

if(abs(dx)>abs(dy))

step=abs(dx);

else

step=abs(dy);

xinc=dx/step;

yinc=dy/step;

x=x1;

y=y1;

putpixel(x,y,1);

for(k=1;k<=step;k++)

{

x=x+xinc;

y=y+yinc;

putpixel(x,y,2);

}

}

C++ imposes far greater restrictions on pointer typing than assembly language. There is only a single type of pointer in assembly, which is only "typed" in any sense when dereferenced, and even then only by size. C++ pointer typing takes into account not only the size of the type of the referent, but a number of other factors, such as its relationship to other types in the class hierarchy. The only way to disable these safety checks is to explicitly break the type system using reinterpret_cast.

You can find in-depth information on how to use sscanf() in C file handling on crasseux.com/books/ctutorial/sscanf.html

One more useful website of learning basic of "c programming" is cprogramming-bd.com

With an unsorted list you have to search from the beginning to locate the item you're looking for. This is a linear search which takes linear time O(n) for n items. That is, the best case is constant time O(1) if the item you're looking for is the first item, it is O(n) if it is the last item (or the item doesn''t exist). Thus, on average, searches will take O(n/2) if the item exists, but always takes O(n) if it doesn't.

With a sorted list you start in the middle of the list. If the item you're looking for is less than this item, you can safely discard the upper half of the list but if it is greater you can discard the lower half. In other words you reduce the number of items to be searched by half. You then repeat the process with the remaining half. If the item you're looking for is equal to the middle item, you're done, but if the remaining half has no items the item does not exist. This is a logarithmic search with a best case of O(1), a worst case of O(log n) and an average case of O((log n)/2).

Logarithmic searches are clearly faster, on average, than linear searches. However, logarithmic searches require two separate comparison operations (equal to and less than) while linear searches require just one (equal to). Thus for a list of three or four items, a linear search is arguably quicker. But for larger lists, logarithmic search is quicker. Note that we don't need to test for greater than since it can be assumed that if an item is neither less than or equal to another item, then it must be greater.

Passing by value is where you pass the actual value (be it an integer, an array, a struct, etc.) to a function. This means that the value must be copied before the function is called and therefore the value in the caller cannot be modified within the callee. Passing by reference is where a reference/pointer to a value is passed to a function. The reference often takes up less space than copying the actual value (particularly when the value is a struct or an array) and allows you to manipulate the value in the caller within the callee.

Loops are used in C to speed up algorithms that do a process repeatedly with the same or very similar values. For example, if you have to write a program to add together all of the number 1 to 10 and print out the value you get you could do it 2 ways:

1. Without a loop:

int a = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10;

printf("%d", a);

2. With a loop:

int a = 0;

for(int i = 1; i <= 10; i++){

a += i;

}

printf("%d", a);

As you can see, solution 2 took about the same amount of time to code as solution 1 BUT when you get into more complex things, or just things that involve more values, loops come in handy. For example, say you want to add up all of the numbers from 1 to 100 or 1 to 1000, it would take much longer to write that out as hard code rather than just to use a loop.

It's in essence (from a very high-level view), when a node is attacked and then "captured". So first we need to define "node". A node can be like your laptop, a switch at the ISP (CenturyLink, etc.), a router, etc.

Think of it like streets. The car (data), drives along through an intersection (a node), and keeps driving along until it makes it to wherever it's headed (say your computer. Well let's say your tired of always having red lights at a certain intersection, so one day you decide that you take over the "light control box". Traffic is still going through, but you control it. We could even say that the "light control box" is connected to the "traffic camera" box. So now, aside from controlling the cars (data/packets), you can also capture their license plates, and in essence "capture the packet". Now that you can control the traffic, and you know what cars drive through when and from where, and how often, you decide to do some "post-exploitation attacks". You decide that you'll redirect traffic from the highway to the one way street (flood attack), or hijack cars, switch license plates, etc.

Poor example, but hopefully that helps some.

Accept 5 numbers in an array and display it.

That means, roughly speaking, that for any input of size "x", the algorithm will take no longer than xn for some constant "n".

#include main() { int array[100], minimum, size, c, location = 1; printf("Enter the number of elements in array\n"); scanf("%d",&size); printf("Enter %d integers\n", size); for ( c = 0 ; c < size ; c++ ) scanf("%d", &array[c]); minimum = array[0]; for ( c = 1 ; c < size ; c++ ) { if ( array[c] < minimum ) { minimum = array[c]; location = c+1; } } printf("Minimum element is present at location number %d and it's value is %d.\n", location, minimum); return 0; }

symbolic constants are constants represented by symbols....

constants are values that does not change through out the program execution.

e.g

#include<stdio.h>

#include<conio.h>

#define NUM 15

void main()

{

int a=NUM;

printf("The constant is %d",a);

getch();

}

here #define is a preprocessor. its job is to replace all the entries named NUM as 15. So that the compiler works with the constant 15...

crash prob is at an elevated level

#include<iostream>

#include<map>

#include<string>

#include<sstream>

#include<conio.h>

struct Cellphone

{

std::string product_id;

std::string product_no;

std::string country;

std::string brand;

double cost;

};

std::ostream& operator<< (std::ostream& os, const Cellphone& phone)

{

os << "Product ID: " << phone.product_id << std::endl;

os << "Product No: " << phone.product_no << std::endl;

os << "Country: " << phone.country << std::endl;

os << "Brand: " << phone.brand << std::endl;

os << "Cost: " << phone.cost << std::endl;

return os;

}

// Global...

std::map<std::string, Cellphone> cellphones;

// forward declarations

size_t choice (std::string);

std::string get_string (std::string prompt);

double get_double (std::string prompt);

void add();

void remove();

void search();

void view();

int main()

{

while (1)

{

std::cout << "MAIN MENU\n=========\n\n";

std::cout << "[A] Add\n";

std::cout << "[V] View\n";

std::cout << "[S] Search\n";

std::cout << "[R] Remove\n";

std::cout << "[Q] Quit\n";

switch (choice ("AVSRQ"))

{

case 0: add(); break;

case 1: view(); break;

case 2: search(); break;

case 3: remove(); break;

default: return 0;

}

}

}

void add ()

{

std::cout << "\nAdd Cellphone\n\n";

Cellphone phone;

phone.product_id = get_string ("Product ID");

phone.product_no = get_string ("Product #");

phone.country = get_string ("Country");

phone.brand = get_string ("Brand");

phone.cost = get_double ("Cost");

cellphones[phone.product_id] = phone;

std::cout << std::endl;

}

void remove ()

{

std::cout << "\nRemove Cellphone\n\n";

std::string id = get_string ("Product ID");

cellphones.erase (id);

}

void search ()

{

std::cout << "\nSearch for Cellphone\n\n";

std::string id = get_string ("Product ID");

std::map<std::string, Cellphone>::const_iterator it = cellphones.find (id);

if (it choices.npos)

continue;

return pos;

}

}

#include <stdio.h>

#include <ctype.h>

#define n[]

int main()

{

int n, result , answer;

int a[n], b[n];

printf("Enter number of terms you would like to use :");

scanf("%d", &n);

printf("Enter first vector:\n");

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

printf("Enter second vector:\n");

scanf("%d", &b[n]);

printf("The dot product is \n" );

return 0;

}

All data is stored in a computer as 0s and 1s. In order to make this more efficient, certain sets of bits can mean different things depending on what the data type is. Some languages, such as Java, make sure the programmer doesn't confuse these types and mess up the data. However, other languages allow you to do things like multiply a string and an array. If you don't pay careful attention to data types, you can easily end up with useless data.

Let us first define a generic Shape class. This will be an abstract class, since the term "shape" is, itself, very abstract.

Let us also assume that this shape is defined in only two dimensions, for the sake of simplicity.

abstract class Shape {

/*

One of the properties of any 2D shape is the area it takes up. Since calculating the area depends on the shape, we'll make this method abstract - all subclasses should implement it differently.

*/

abstract int getArea();

}

Now that we have our base class defined, we can create a rectangle subclass.

class Rectangle extends Shape {

/*

While a rectangle has other properties, we are really only interested in the ones required to calculate the area - width and height.

*/

int width;

int height;

/*

What's the area of a rectangular shape?

area = width x height

*/

int getArea() {

return width*height;

}

}