Huffman coding

[code]
//Originally FOUND in Internet
//by RIT2009061 vikesh iiita

//Author: Ujjal Suttra DHar [CSE’08,RUET]

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <queue>
#include <algorithm>

using namespace std;

struct node {
int weight;
char value;
const node *child0;
const node *child1;

node( int c, int i ) {
value = c;
weight = i;
child0 = 0;
child1 = 0;
}

node( const node* c0, const node* c1 ) {
value = 0;
weight = c0->weight + c1->weight;
child0 = c0;
child1 = c1;
}

bool operator<( const node &a ) const {
if(weight ==a.weight)
return value>a.value;
else
return weight >a.weight;
}

void traverse(string code="") const{

if ( child0 ) {
child0->traverse( code + ‘0’ );
child1->traverse( code + ‘1’ );
} else {
cout <<" " <<value <<" ";
cout <<weight;
cout <<" " <<code <<endl;
}
}

};

/*
void count_chars( int *counts )
{
for ( int i = 0 ; i <256 ; i++ )
counts[ i ] = 0;

freopen("input.dat","r",stdin);

char c;
while((c=getchar())!=EOF)
counts[c]++;
}

*/

int main()
{

freopen("input.dat","r",stdin);

int counts[ 256 ];
char a[1000];

gets(a);

for ( int i = 0 ; i <256 ; i++ )
counts[ i ] = 0;

for(int i=0;i<strlen(a);i++)
counts[a[i]]++;

priority_queue < node > q;

for (int i = 0 ; i <256 ; i++ )
if ( counts[ i ] )
q.push( node( i, counts[ i ] ) );

//if you wanna show the queue
/*while(!q.empty()){
cout<<q.top().value<<endl;
q.pop();
}
*/

while ( q.size() >1 ) {
node *child0 = new node( q.top() );
q.pop();
node *child1 = new node( q.top() );
q.pop();
q.push( node( child0, child1 ) );
}

cout <<"CHAR FREQUENCY HOFFMAN-CODE" <<endl;
q.top().traverse();
return 0;
}

[/code]

BigInt by Jan vai

/**
*Author : Jan
*Problem Name : Big int for contest
*Algorithm :
*Complexity :
**/

#include <cstdio>
#include <string>
#include <cstring>
#include <algorithm>
#include<iostream>
using namespace std;

struct Bigint {
string a;
int sign;

Bigint() {}
Bigint( string b ) { (*this) = b; }
int size() { return a.size(); }
Bigint inverseSign() { sign *= -1; return (*this); }
Bigint normalize( int newSign ) {
sign = newSign;
for( int i = a.size() - 1; i > 0 && a[i] == '0'; i-- ) a.erase(a.begin() + i);
if( a.size() == 1 && a[0] == '0' ) sign = 1;
return (*this);
}
void operator = ( string b ) {
a = b[0] == '-' ? b.substr(1) : b;
reverse( a.begin(), a.end() );
this->normalize( b[0] == '-' ? -1 : 1 );
}
bool operator < ( const Bigint &b ) const {
if( a.size() != b.a.size() ) return a.size() < b.a.size();
for( int i = a.size() - 1; i >= 0; i-- ) if( a[i] != b.a[i] ) return a[i] < b.a[i];
return false;
}
Bigint operator + ( Bigint b ) {
if( sign != b.sign ) return (*this) - b.inverseSign();
Bigint c;
for( int i = 0, carry = 0; i < (int)a.size() || i < (int)b.size() || carry; i++ ) {
carry += (i < (int)a.size() ? a[i] - 48 : 0) + (i < (int)b.a.size() ? b.a[i] - 48 : 0);
c.a += (carry % 10 + 48);
carry /= 10;
}
return c.normalize(sign);
}
Bigint operator - ( Bigint b ) {
if( sign != b.sign ) return (*this) + b.inverseSign();
if( (*this) < b ) return (b - (*this)).inverseSign();
Bigint c;
for( int i = 0, borrow = 0; i < (int)a.size(); i++ ) {
borrow = a[i] - borrow - (i < b.size() ? b.a[i] : 48);
c.a += borrow >= 0 ? borrow + 48 : borrow + 58;
borrow = borrow >= 0 ? 0 : 1;
}
return c.normalize(sign);
}
Bigint operator * ( Bigint b ) {
Bigint c("0");
for( int i = 0, k = a[i]; i < (int)a.size(); i++, k = a[i] ) {
while(k-- - 48) c = c + b;
b.a.insert(b.a.begin(), '0');
}
return c.normalize(sign * b.sign);
}
Bigint operator / ( Bigint b ) {
if( b.size() == 1 && b.a[0] == '0' ) b.a[0] /= ( b.a[0] - 48 ) ;
Bigint c("0"), d;
for( int j = 0; j < (int)a.size(); j++ ) d.a += "0";
int dSign = sign * b.sign; b.sign = 1;
for( int i = a.size() - 1; i >= 0; i-- ) {
c.a.insert( c.a.begin(), '0');
c = c + a.substr( i, 1 );
while( !( c < b ) ) c = c - b, d.a[i]++;
}
return d.normalize(dSign);
}
Bigint operator % ( Bigint b ) {
if( b.size() == 1 && b.a[0] == '0' ) b.a[0] /= ( b.a[0] - 48 ) ;
Bigint c("0");
int cSign = sign * b.sign; b.sign = 1;
for( int i = a.size() - 1; i >= 0; i-- ) {
c.a.insert( c.a.begin(), '0');
c = c + a.substr( i, 1 );
while( !( c < b ) ) c = c - b;
}
return c.normalize(cSign);
}
void print() {
if( sign == -1 ) putchar('-');
for( int i = a.size() - 1; i >= 0; i-- ) putchar(a[i]);
}
};

int main() {

Bigint a, b, c;
string p,q;

cin>>p>>q;
a=p;
b=q;

c = a + b;

c.print();

putchar('\n');

c = a - b;
c.print();
putchar('\n');

c = a * b;
c.print();
putchar('\n');

c = a / b;
c.print();
putchar('\n');

c = a % b;
c.print();
putchar('\n');

return 0;
}

JAVA [creating Jar files]

To create a jar file execute this command given below

[code]
jar cf jar-file input-file(s)
[/code]
//input files are .class files and extra files you have used like music,jars etc.

For more you can see this Creating JAR files
After creation you must specify the main class using manifest.

Ways to update a jar file with manifest……
I have created a text file as manifest like aaa.txt which contains

[Code]Main-class: Mainclassname
[/Code]
//a new line or enter must be pressed after Mainclassname before saving

Updating a jar file with main class, you have to move the jar file to the BIN folder of JDK. Then using the command propmt executed the commands given below:

[code]
jar umf aaa.txt calender.jar
jar xvf calender.jar
type META-INFMANIFEST.MF
[/code]
Now double-click on your JAR file….

Thanking you,
Ujjal

Stack Implementation in Assembly Language (Algebric expression is correct or not.)

Problem description:
This is a problem in elementary algebra is to decide if a given algebric expression containing several kinds of brackets,such as [,],{,},(,), is correctly bracketed or not.

For example:
(a+[b-{c*(d-e)}]+f) is correctly bracketed but (a+[b-{c*(d-e)]}+f) is not correctly bracketed.

Solution:
This is the case if
(a) There are the same number of left and right bracketes of each kinds,and
(b) When a right bracket appears,the most recent preceeding unmatched left bracket should be of the same type.
This can be decided by using stack. The expression is scanned left to right. When a left bracket is encountered,it is pushed onto the stack. When a right bracket is encountered, the stack is poped (if the stack is empty ,there are too many right brackets) and the brackets are compared. If they are of the same type,the scanning continues.If there is a mismatch,the expression is incorrectly bracketed. At the end of the expression ,if the stack is empty ,the expression is correctly bracketed otherwise there are too many left brackets.
[code]
.model small
.stack 100h
.data

cr equ 0DH ; cr represents carriage return
lf equ 0AH ; lf represents line feed

msg DB cr,lf,’ENTER AN ALGEBRIC EXPRESSION : ‘,cr,lf,’$’
msg_correct DB cr,lf,’EXPRESSION IS CORRECT.$’
msg_left_bracket DB cr,lf,’TOO MANY LEFT BRACKETS. BEGIN AGAIN!’,cr,lf,’$’
msg_right_bracket DB cr,lf,’TOO MANY RIGHT BRACKETS. BEGIN AGAIN!’,cr,lf,’$’
msg_mismatch DB cr,lf,’BRACKET MISMATCH. BEGIN AGAIN!’,cr,lf,’$’
msg_continue DB cr,lf,’Type Y if you want to Continue : ‘,cr,lf,’$’

.code

main proc

mov ax,@data ;get data segment
mov ds,ax ;initialising

start:
lea dx,msg ;user prompt
mov ah,9
int 21h

xor cx,cx ;initializing cx
mov ah,1

input: ;this label for taking input

int 21h

cmp al,0Dh ;checking if the enter is pressed or not
JE end_input

;if left bracket,then push on stack
cmp al, "["
JE push_data
cmp al, "{"
JE push_data
cmp al, "("
JE push_data

;if right bracket,then pop stack

cmp al, ")"
JE parentheses
cmp al, "}"
JE curly_braces
cmp al, "]"
JE line_bracket
jmp input

push_data:
push ax
inc cx
jmp input

parentheses:
dec cx
cmp cx,0
JL many_right

pop dx
cmp dl, "("
JNE mismatch
JMP input

curly_braces:
dec cx
cmp cx,0
JL many_right
pop dx
cmp dl, "{"
JNE mismatch
JMP input

line_bracket:
dec cx
cmp cx, 0
JL many_right
pop dx
cmp dl, "["
JNE mismatch
JMP input

end_input:
cmp cx, 0
JNE many_left

mov ah, 9
lea dx, msg_correct
int 21h

lea dx, msg_continue
int 21h

mov ah,1
int 21h

cmp al, "Y"
JNE exit
JMP start

mismatch:
lea dx, msg_mismatch
mov ah,9
int 21h
JMP start

many_left:
lea dx, msg_left_bracket
mov ah,9
int 21h
JMP start

many_right:
lea dx, msg_right_bracket
mov ah,9
int 21h
JMP start

exit:
mov ah,4ch
int 21h

MAIN ENDP
END MAIN
[/code]

Difficulties & Discussion:
Since I have already solved this problem in C, I hadn’t face too much problem for the algorithm to solve this in assembly language. All dificulties I faced was in the syntax of Assembly language. At first,finishing the code,it wasn’t working for some inputs like (a+b)) or (a+b)} for which output will be “TOO MANY RIGHT BRACKETS”. But my code was being redirected to starting position of main procedure because of my silly mistake.Thsi mistake was in line number 83,94 and 104.

Wrong code
[code] pop dx
dec cx
cmp cx,0
JL many_right
cmp dl, "{"
JNE mismatch
JMP input[/code]
Corrected code:
[code]
dec cx
cmp cx,0
JL many_right
pop dx
cmp dl, "{"
JNE mismatch
JMP input

[/code]

For the example (a+b)}
When the last ‘}’ is scanned,then stack is empty.but in the code I have poped from stack,which is an invalid instruction. But actually it is required that,I will first check if the stack is empty or not.If empty,then “too many right brackets”. If not then pop dx and should be checked with the scanned data.It was done in the right side code.

This problem is an application of stack implementation and we have successfully solved this using stack in assembly language.

Inheritance in OOP

আজাইরা থাকতে থাকতে হটাত্‌ মনে হইল অনেক দিন প্যানর প্যানর করা হয়। তাই চলে আসলাম আবার আমার দুনিয়ায়। আজকে আমি OOP এর Inheritance নিয়া কিছু কথা বলব। পুরাটাই বাংলায় লিখতে পারতাম,কিন্তু কতিপয় STUDENT দের আবার exam এ বাংলা লেখতে পারবে না বলে tutorial টা ইংরেজিতে দিয়া দিলাম।
এখন আসি আসল কথায়…………………।

Base-Class Access Control
When a class inherits another,the members of the base class become members of the derived class.
Class inherits uses the general form:
[code]
class derived-class:access base-class{
//body of class
};
[/code]

The access status of the base class’s members inside the derived class is determined by the access.
There are three types of access specifier.They are public,private and protected. If no access specifier is present, the access specifier is by default private.

When the access specifier for a base class is public, all public members of the base class become public members of the derived class and all protected members of the base become protected members of the derived class.

In all cases,the base’s private members remain private for the derived class and are not accessible by members of derived class.

When the access specifier for a base class is private, all public and protected members of the base class become private members of the derived class.

When the access specifier for a base class is protected, all public and protected members of the base class become protected members of the derived class.

See example from your text books for the better conception.

TLE খাওয়া একজন পথিক এর গল্প

Online programming করার জন্য track your progress এ থাকা হয় সবসময়। আমরা কয়েকজন যেমন অনিক শোভন আর আমি chatting করতাম। যাই হোক, ওদিকে যাইয়া লাভ নাই।কিছুদিন Uva onlinejudge তে problem solve করতাম। আমি মাঝখানে বাদ দিয়া দিলাম।কিন্তু ওরা চালাইয়া গেল আর এক এক জন বস হইয়া গেল। আমি টানা ৩-৪ মাস পর ওইদিন আবার Felix Halim ভাইয়ের সাইট টাতে ঢুকে দেখলাম অনিক শোভন কে বলছে, ভাই,১০০৮৩ নাম্বার এর জন্য কোন শর্টকাট নাই।মানুয়ালি করতে হবে। আমি ভাবলাম,অনেকদিন problem solve করা হয় না। এইটা try করি। দেখলাম problem টা Big Number এর। তাই JAVA এর BigInteger এর class ব্যবহার করে solve করে ফেললাম। কিন্তু TLE খাইলাম। এইবার নিজে optimize করার চেষ্টা করলাম।অনেক টাই করলাম।কিন্তু লাভ হল না। পর পর কয়েকবার TLE খাইলাম.এইত গেল প্রথম দিনের ঘটনা। পর দিন অনিক কে বললাম hints দেওয়ার জন্য। ও যা বলল ,তাতে আমি কিছু তা আশা পেলাম। মানে ওর বুদ্ধিতে কিছুটা time কমলো। যাই হক এইবার আর submit করতে পারলাম না।কারন 3rd case এ code টা infinity টে গেল। এইবার শোভন কে বললাম আমার code টা দেখে দিতে। ও কিছু condition add করতে বলল। হা,এইবার আমি খুশি,কারন ওই 3rd case এ এখন আর সমস্যা নেই। কিন্তু আবার TLE.[oh noo!!!] ওইদিন রাতে শোভন কে প্রায় ৪-৫ ঘন্টা খাটাইছি নিজের সার্থ উদ্ধারের জন্য । যাই হোক,শেষ পর্যন্ত divide() function টার কাজ manually করলে টাইম কমবে এই আসায় ওইদিন রাতে কয়েকটা TLE খাওয়ার পর খান্ত দিলাম কারন পরদিন সকালে class আছে। সকালে দেরি করে ঘুম থেকে উঠলাম। মানে class শুরুর আর মাত্র ৫ মিনিট বাকি। আমি dress up করে roommate এর হাতে খাতা টা দিয়ে বললাম class এ চলে যেতে। আমি ব্রাশ নিয়ে দাত মাজতে মাজতে ৩ তালা থেকে নিচে নেমে মুখ ধুয়ে ব্রাশ টা পকেট এ রেখে দৌড় দিয়ে class এ যাই।খুব বেশি দেরী হয় নি। এইবার আসল কথায় আসি, ফেলিক্স হালিম ভাইয়ের ওই সাইট তাতে post দিলাম আমার সমস্যা নিয়ে। nhahtdh আমাকে Reply দিলেন । উনি আমাকে যা করতে বললেন তা আমি আগেই করে রেখেছি। তারপর উনি নিজে solve করে ৩ বার TLE,2 বার WA খাওয়ার পর finally Accepted এর মুখ দেখলেন।দেখা গেল আমি শুধু মাত্র একটা check না করার জন্য TLE খাচ্ছিলাম। ঠিক করলাম। ৩ দিন পর Accepted নামক বাস্তটার মুখ দেখলাম।

মজার ব্যপার যা ঘটল,তা হচ্ছে আমার code টা nhahtdh ভাইয়ের থেকে ৫০% কম সময়ে output দিচ্ছিল। পরে অবশ্য উনি সমস্যা খুজে বের করেচ্ছিলেন উনার code এর।
এই ৩ দিনে আমার অর্জনঃ
2 টা WA ,
3 টা RE,
2 টা CE
9 টা TLE
logarithm ব্যবহার করে division জানতাম না আগে।।এইটা শিখে ফেললাম।
C++ এর String এ যা JAAN ভাইয়ের BigNumber এর যা code ছিল টা জ়াভা টে convert করে ফেললাম।
যদিও এই ২টার কোনটাই এইটায় লাগে নাই।

অবশেষে বাংলা-English এর মিশ্রণ এর জন্য খুবই দুঃখিত।

Bellman-Ford Algorithm

The Bellman-Ford algorithm solves the single-source shortest-paths problem in the general case in which edge weights may be negative. Given a weighted, directed graph G = (V, E) with source s and weight function w : E → R, the Bellman-Ford algorithm returns a Boolean value indicating whether or not there is a negative-weight cycle that is reachable from the source. If there is such a cycle, the algorithm indicates that no solution exists. If there is no such cycle, the algorithm produces the shortest paths and their weights. The algorithm uses relaxation, progressively decreasing an estimate d[v] on the weight of a shortest path from the source s to each vertex v ∈ V until it achieves the actual shortest-path weight δ(s, v). The algorithm returns TRUE if and only if the graph contains no negative-weight cycles that are reachable from the source.

To understand this algorithm, we must know about the storing technique of graph.

The Algorithm
The Bellman-Ford algorithm is one of the classic solutions to this problem. It calculates the shortest path to all nodes in the graph from a single source.

The basic idea is simple:
Step 1: Start by considering that the shortest path to all nodes, less the source, is infinity. Mark the length of the path to the source as 0:

Step 2: Take every edge and try to relax it:

Relaxing an edge means checking to see if the path to the node the edge is pointing to can’t be shortened, and if so, doing it.
Now, we apply the previous step n – 1 times, where n is the number of nodes in the graph.

For example Click here

Here is the condensed form of the algorithm :
[code]
void bellman_ford(int s) {
int i, j;

for (i = 0; i < n; ++i)
d[i] = INFINITY;

d[s] = 0;

for (i = 0; i < n – 1; ++i)
for (j = 0; j < e; ++j)
if (d[edges[j].u] + edges[j].w < d[edges[j].v])
d[edges[j].v] = d[edges[j].u] + edges[j].w;
}
[/code]

***the structure is
[code]
typedef struct{
int u,v,w;
}Edge;
Edge edges[1000];
[/code]

It is seen that the working principle of Bellman-Ford algorithm is exactly same as another single source shortest path Dijkstra’s algorithm. Then what is the difference between them?

Yes, their working principle is same but Dijkstra’s algorithm fails if there exists any negative valued weight or negative cycle. But Bellman-Ford algorithm is capable to determine the negative cycle in the graph and finds the shortest path even with negative valued weights.

Here is an real life example of bellman-Ford example . UVA 558

[code]
//warmholes 558
#include <stdio.h>

typedef struct {
int u, v, w;
} Edge;

int n; /* the number of nodes */
int e; /* the number of edges */
Edge edges[2500]; /* large enough for n <= 2^5=32 */
int d[1500]; /* d[i] is the minimum distance from node s to node i */

#define INFINITY 1000000

void printDist() {
int i;
printf("Distances:n");
for (i = 0; i < n; ++i)
printf("to %dt", i );
printf("n");

for (i = 0; i < n; ++i)
printf("%dt", d[i]);

printf("nn");
}

void bellman_ford(int s){
int i, j;

for (i = 0; i < n; ++i)
d[i] = INFINITY;

d[s] = 0;

for (i = 0; i < n-1; ++i)
for (j = 0; j <e; ++j){
if (d[edges[j].u] + edges[j].w < d[edges[j].v])
d[edges[j].v] = d[edges[j].u] + edges[j].w;
}

////these 3 lines for the 558////////////////
int f=0;
for (int j = 0; j < e; j++)
if (d[edges[j].v] > d[edges[j].u] + edges[j].w) {
f=1;break;
}

if(f==1)
printf("possiblen");
else
printf("not possiblen");

}

int main() {
int i,p,j,k,c,l,m,kase;
int w;

scanf("%d",&kase);
for(c=0;c<kase;c++){

scanf("%d %d",&n,&e);
p=0;

for(i=0;i<e;i++){
scanf("%d %d %d",&j,&k,&l);
edges[i].u=j;
edges[i].v=k;
edges[i].w=l;
}
bellman_ford(0);
//printDist();
}
return 0;
}

[/code]

References:
“Introduction to algorithms ” by Coreman
http://compprog.wordpress.com/2007/11/29/one-source-shortest-path-the-bellman-ford-algorithm/

অ্যাসেম্বলি ল্যাঙ্গুয়েজ় প্যানর প্যানর।

অ্যাসেম্বলি ল্যাঙ্গুয়েজ় একটা ভয়াবহ ল্যাঙ্গুয়েজ ,এইটার বই পরতে গিয়ে অনেকে এখনো শহীদ হয়েছে বলে লোকমুখে অনেক জনশ্রুতি আছে , সেই অজস্র বিদেহী আত্মার একজন হয়ে,অজস্র জীবিত আত্মাকে বাঁচানোর এক ক্ষুদ্র প্রয়াস আমার এই প্যানর প্যানর।
বাঙ্গালি নারীদের পরপুরুষে আসক্তি আছে কিনা,আমার বোঝার বয়স হই নাই ,তবে বাচ্চাকালে পরেছি ,ভারতের টোডা উপজাতির নারীদের একাধিক বর থাকে ,আমাদের সবার প্রেয়সী কম্পুবিবির ও আছে । ভারতের টোডা উপজাতির নারীদের শৌর্য-বীর্য প্রকাশ পায় একাধিক পুরুষ এর সাথে সাথে চলা ফেরায় ,কথা বার্তায় আর “হালুম-এ” । আমাদের কম্পুবিবিকে ও অনেকের সাথে অনেক ঢঙ্গে অনেক কথা বলতে হয়,অনেকের অনেক নীরব আকুতি সরবভাবে মেটাতে হয়।( প্যানর প্যানর বাদ দিয়ে আসল কথায় আসি ) কম্পুবিবি অজস্র আকুতি পূরণ করে একটা বিশেষ উপায়ে ।
তিনি কিছু সংখ্যা ছাড়া কিছুই বুঝেন না , তাহলে এত প্রেমিক পুরুষ কীভাবে ম্যানেজ করেন ,আর কীভাবে প্রেমের জোয়ারে বন্যা হয়ে যায় ? নারীশাসিত এই আধুনিক সমাজে পুরুষরা নারীর মন জুগিয়ে চলে (কারন পুরুষরা মহান!!) ,আর তাই নারীর যে ভাষা বুঝে ,তাদের কে পুরুষরা সে ভাষায় কবিতা শোনায় ,আর সে কবিতা পরে সংখ্যার মাধ্যমেই আদান প্রদান হয় ।
একটা উদাহারণ দেই তাহলে বুঝতে সুবিধা হবে । কেউ যদি কম্পিউটার কে কোন ভাবে বলে ১৪৩(বাইনারী তে বলতে হবে I LOVE YOU) তাহলে সে বুঝে নিবে যে তাকে যে কেউ ভালোবাসে । মানে কেউ বললো I LOVE YOU তখন সেইটা কে তো ১৪৩(বাইনারী) তে কনভার্ট করতে হবে ? এই কাজ করে “অ্যাসেম্বলার” । এর কাজ হচ্ছে যে কোন কিছুকে machine code এ রূপান্তর করা আর কম্পিউটার machine code অনুযায়ী কাজ করে । তাহলে আমরা যদি কম্পিউটার কে কোন কিছু করতে বলি আমাদের জানতে হবে অ্যাসেম্বলি ল্যাঙ্গুয়েজ় । অ্যাসেম্বলার নামের একটা সফটওয়ার এই ভাষাকে রূপান্তর করবে machine code এ ,কম্পিউটার সেই machine code পরে পরে কাজ করবে । আমরা যারা সি এর প্রোগ্রাম করি ,তখন আমরা যা লিখি সেইটা কম্পাইলার প্রথমে অ্যাসেম্বলি ল্যাঙ্গুয়েজ় এ রূপান্তর করে তারপর machine code এ রূপান্তর করে ,সেইটা দিয়ে আমাদের কোডের কাজগুলো কম্পিউটার করে । আমার লেখার স্পীড অনেক কম , আস্তে আস্তে বাকীটা লিখবো ,আজ কে এতটুকুই ।

শহীদ শাকিল নিহন
বিশিষ্ট কমপু প্রেমিক
————

Starting TOPCODER

To start contest you must Register to open an account in topcoder.

Then you have to download ContestAppletProd.jnlp to take part in the contests. To download this go to this page and click on “Launch Arena” on the leftside.

After completing download you are ready to start participating on contests. You have to register for any contest before 5 minutes of starting of the contest. You have to login on topcoder by this applet.

Before starting contest we must learn enough. Tutorials is the best tutorial I have seen.

To know about contest Rules HELP

Remarks:
1. You have not to submit your main(). you have to submit just the header files and the class part.

example:
[code]
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cstring>
using namespace std;

class ToastXRaspberry{

public:
int apply(int upper_limit, int layer_count){

if(upper_limit>=layer_count)
return 1;

int x=layer_count/upper_limit;

if(layer_count%upper_limit>0)
x+=1;

return (x);
}
};

[/code]
Class name and method name will be given in the problem description.

Object Oriented programming

আমরা জীবজগতের শ্রেণীবিন্যাস জানি। যেমন : মানুষের বৈজ্ঞানিক নাম Homo sapiensMammalia বা স্তন্নপায়ী শ্রেণীর একটি প্রাণী মানুষ। এ শ্রেণীতে রয়েছে বানর ও শিমপান্জী সহ আরও অনেক। তাহলে,Mammalia class টির সকল বৈশিষ্ট্য মানুষ,বানর ও শিমপান্জীর রয়েছে। অর্থাৎ Mammalia Class এর Object হল মানুষ/বানর/শিমপান্জী কারন এরা প্রত্যেকে Mammalia Class টির Representative । এটাই OOP এর মৌলিক ধারনা।

C ও C++ এর মধ্যে পার্থক্য হল C++ এ OOP(Object Oriented programming) এর সুবিধা রয়েছে যা JAVA তে পূর্ণতা পেয়েছে ।
Object Oriented programming আমাদের যে সুফলগুলো দিয়েছে সেগুলো হলঃ
01. Data Encapsulation
02. Data Hiding
03. Polymorphism
এই তিনটি সম্পর্কে পরবর্তীতে বিস্তারিত বলব।

প্রোগ্রামিং করার সময় আমরা যখন কোন Class এর Declaration দিব তখন ঐ Class এর বস্তু বা Object এর কি কি বৈশিষ্ট্য থাকবে তা নির্ধারণ করে দেব। দুই ধরণের বৈশিষ্ট্য থাকতে পারে, ১। Attribute ২। Member function

উদাহরন:
[code]
Class Car{ // Car is the user defined classname
//these three are attribue of the class Car
Char carname[20];
int wheel;
char color;

//these are the member functions
void getnameofcar(){
cin>>carname;
}
void getnumberofwheel(){
cin>>wheel;
}
}; //a semicolon must be placed after the declarationof that class
[/code]
তাহলে দেখা যাচ্ছে যে Car শ্রেণীর সকল Object এর তিনটি Attribute থাকবে যথাঃ carname,wheel এবং color । এবং ২ টি function আছে। এই বৈশিষ্ট্যগুলো তিন ধরনের হতে পারে যথাঃ public, private and protected.

An example :
[code]
#include<stdio.h>
#include <iostream>
using namespace std;

Class Car{ // Car is the user defined classname
//these three are attribue of the class Car
Char carname[20];
int wheel;
char color;

//these are the member functions
void getnameofcar(){
cin>>carname;
}
void getnumberofwheel(){
cin>>wheel;
}
}; //a semicolon must be placed after the declarationof that class

int main(){

Car obj1,obj2; // declaring of an object of Class Car

obj1.getnameofcar(); // calling the function for obj1
obj1.getnumberofwheel();

obj2.getnameofcar(); // calling the function for obj2
obj2.getnumberofwheel();

cout<<ob1.carname<<endl;
cout<<ob1.wheel<<endl;

cout<<ob2.carname<<endl;
cout<<ob2.wheel<<endl;

return 0;
}[/code]
/////////////////////////////////////////

Definitions:
A class is a template for multiple objects with similar features. Classes embody all the
features of a particular set of objects.

An instance of a class is another word for an actual object. If classes are an abstract
representation of an object, an instance is its concrete representation.

Object is the more general term, but both instances and objects are the concrete representation of a class.
In fact, the terms instance and object are often used interchangeably in OOP language. An instance of a Car and a Car object are both the same thing.