C Programming

Mov ax,data

mov ds,ax

mov dl,05h

up2: lea si,ser1

mov cl,05h

up1: mov al,ds:[si]

mov ah,al

inc si

cmp al,ds:[si]

jc down

mov ah,ds:[si]

mov ds:[si],al

dec si

mov ds:[si],ah

inc si

down:dec cl

jnz up1

dec dl

jnz up2

int 3h

#include <stdlib.h>

#include <stdio.h>

#define uint unsigned int

typedef int (*compare_func)(int, int);

void heap_sort(int This[], compare_func func_pointer, uint len)

{

/* heap sort */

uint half;

uint parents;

if (len <= 1)

return;

half = len >> 1;

for (parents = half; parents >= 1; --parents)

{

int tmp;

int level = 0;

uint child;

child = parents;

/* bottom-up downheap */

/* leaf-search for largest child path */

while (child <= half)

{

++level;

child += child;

if ((child < len) &&

((*func_pointer)(This[child], This[child - 1]) > 0))

++child;

}

/* bottom-up-search for rotation point */

tmp = This[parents - 1];

for (;;)

{

if (parents child)

break;

if ((*func_pointer)(tmp, This[child - 1]) <= 0)

break;

child >>= 1;

--level;

}

/* rotate nodes from parents to rotation point */

for (;level > 0; --level)

{

This[(child >> level) - 1] =

This[(child >> (level - 1)) - 1];

}

This[child - 1] = tmp;

} while (--len >= 1);

}

#define ARRAY_SIZE 250000

int my_array[ARRAY_SIZE];

void init()

{

int indx;

for (indx=0; indx < ARRAY_SIZE; ++indx)

{

my_array[indx] = rand();

}

}

int cmpfun(int a, int b)

{

if (a > b)

return 1;

else if (a < b)

return -1;

else

return 0;

}

int main()

{

int indx;

init();

heap_sort(my_array, cmpfun, ARRAY_SIZE);

for (indx=1; indx < ARRAY_SIZE; ++indx)

{

if (my_array[indx - 1] > my_array[indx])

{

printf("bad sort\n");

return(1);

}

}

return(0);

}

#include<iostream>

#include<array>

#include<string>

#include<random>

#include<ctime>

using player_t = std::array<unsigned, 2>;

using pair_t = std::pair<unsigned, unsigned>;

using snake_t = std::array<pair_t, 10>;

using ladder_t = std::array<std::pair<unsigned, unsigned>, 9>;

const std::string player (const bool human)

{

return std::string {human ? "You" : "I"};

}

int main()

{

std::default_random_engine generator ((unsigned) time (0));

std::uniform_int_distribution<unsigned> distribution (1, 6);

player_t players = {0,0};

const snake_t snakes = {pair_t {98,78}, {95,75}, {93,73}, {87,24}, {64,60}, {62,19}, {56,53}, {49,11}, {47,26}, {16,6}};

const ladder_t ladders = {pair_t {1,38}, {4,14}, {9,31}, {21,42}, {28,84}, {36,44}, {51,67}, {71,91}, {80,100}};

std::cout << "Snakes and Ladders\n";

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

std::cout << "First to land exactly on square 100 wins.\n";

bool human = (distribution (generator) % 2)==0 ? true : false;

std::cout << player (human) << " will go first.\n\n";

for (;;human=!human)

{

std::cout << (human ? "Your" : "My") << " turn:\n";

unsigned dice = distribution (generator);

std::cout << '\t' << player (human) << " rolled a " << dice << ".\n";

unsigned& pos = players [human?0:1];

if (pos+dice>100)

{

std::cout << '\t' << player (human) << " cannot move";

goto next_player;

}

pos+=dice;

std::cout << '\t' << player (human) << " landed on square " << pos;

for (auto snake : snakes)

{

if (snake.first==pos)

{

pos = snake.second;

std::cout << " with a snake; return to square " << pos;

goto next_player;

}

}

for (auto ladder : ladders)

{

if (ladder.first==pos)

{

pos = ladder.second;

std::cout << " with a ladder; climb to square " << pos;

goto next_player;

}

}

next_player:

std::cout << ".\n\n";

if (pos==100)

{

std::cout << player (human) << " won!\n";

break;

}

}

}

FILE-level: ftell/fseek, fgetpos/fsetpos

handle-level: lseek

A "fall through" is what we call it when a case in a switch statement doesn't end in a break, return, throw, or any other control-breaking statement. In these cases, program execution continues to the next case block (regardless of the value in the switch), and so control "falls through" to the case below it.

Here is an example of a typical switch block:

switch(n) {

case 0:

System.out.println("zero");

break;

case 1:

System.out.println("one");

case 2:

System.out.println("two");

break;

}

Notice the break statements in cases 0 and 2. These are used to break out of the switch block so that only one value is printed out. If n is set to 1 before executing this code, "one" would be printed out and then the program would continue to the next statement and print out "two" as well. That is a fall through.

double round (double x) return (int) x + 0.5;

I want my C++ program become interesting

How can I change the color of background and color of font even size of font.........

I will always use

system("cls")

to clear there screen.....

so I want do C++ DOS into something we call presentation like powerpoint

Haha........

Any tutorial?

That all

Thank you

Retrieving keyboard input depends partly upon whether you're writing a console or graphical application. If you're writing a console application, you have the following functions available:

- sscanf() in the stdio.h header

- getchar() in the stdio.h header

- getch() in conio.h and curses.h (plus kbhit() if it's available)

For Win32 applications, which are event-driven, you'll want to intercept the WM_CHAR event that's passed to your window handler (WndProc). The wParam parameter will contain the character on the keyboard that's pressed.

For other APIs, you'll want to check the documentation, or look on the Web for tutorials describing how to get keyboard input using whichever API you're using.

what is the difference between bloomfield 's structuralism and saussure's structuralism

Never. For example argv[-1] (or -1[argv]) is perfectly legal.

penischaffed

std::cout<<"computer"<<std::endl;

/* emirp_1000.c j. adams

*

* Program to generate prime numbers that are emirps

*

*

* compile with $> gcc -o emirp_1000 emirp_1000.c -lm

*

*

*/

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <math.h>

#define MAX_RANGE 1000

int main(void)

{

int p = 11;

int p2 = 0;

int itr = 0;

int cnt = 0;

int rev = 0;

int skip_val[]= {2, 4, 2, 2, 2, 4, 2, 2, 2, 4, 2, 2, 2, 4, 2, 2};

while(p < MAX_RANGE)

{

cnt = 16;

itr = 0;

while(cnt--)

{

// check p for primeness.

if(isit_prime(p))

{

p2 = p;

// reverse p

while(p2 > 0)

{

rev = rev * 10 + (p2 % 10);

p2 = p2/10;

}

// If rev != p (palindrome) and rev is prime

if((rev ^ p)&&(isit_prime(rev)))

printf("\n%d", p);

}

rev = 0;

p = p += skip_val[itr++];

}

}

printf("\n");

return 0;

}

int isit_prime(int n)

{

int k = 0;

if (n 0)

return 0;

return 1;

}

The short answer is probably these C operators +=, -=, *=, /= * %= are from Algol68′s +:=, -:=, *:=, /:= & %:=.

c.f. usenet: Ada and C and Algol 68

BTW: The best quote about C's ancestry comes from Dennis Ritchie himself:

"The scheme of type composition adopted by C owes considerable debt to Algol 68, although it did not, perhaps, emerge in a form that Algol's adherents would approve of. The central notion I captured from Algol was a type structure based on atomic types (including structures), composed into arrays, pointers (references), and functions (procedures). Algol 68′s concept of unions and casts also had an influence that appeared later." Apr 1993 c.f. Dennis Ritchie (April 1993). "The Development of the C Language" (PDF)

Note that the /= and /:= are subtly different. Also C's %= is the same as Algol's %*:= operator.

Note also that the majority of C's operators came from Algol (+ - * / = ≠ etc ). However the "%" operator is notability different.

* Wikipedia: Monadic_operators

* Wikipedia: Dyadic_operators_with_associated_priorities

C has the "return" and "sizeof" operator, whereas Algol68 has syntax "EXIT" (or "□") and operator "UPB" (or "⌈") that achieve a similar function.

Algol 68 also has some related constants: "max int", "max real", "int width", "real width" etc to determine sizes of things. These are not the same a C's sizeof, but similar.

The most peculiar operators of C's are /\ & \/, these come from Algol's ∧ & ∨ operators. These "C originals" were replaced by the current && and operators. c.f. What _did_ the C operators /\ and \/ do?

Algol68 further allows operators to be define using non-ASCII characters:

×, ÷, ≤, ≥, ¬, ∨, ∧, , ↓, ↑, ⌊, ⌈, ⎩, ⎧ and ⊥;

And used the characters →, ○, □, ␣ and ¢ for other purposes. It is kind of like Algol68 was taking the liberty of using unicode some 20 years before Unicode characters were defined. {Earlier Algol60 used non-ASCII ⊂ and ≡}

* C's: int i = b ? a : b; /* pick maximum */

* A68′s: INT i := ( a > b | a | b );

c.f. Wikipedia: ?: - a ternary operator

The assignment ":=" looks like an operator, but in terms of "Algol68″ OPerators it isn't. I believe they are called "Units associated with names" c.f. Array, Procedure, Dereference and coercion operations

(Or - if you are a language lawyer c.f. Algol 68 r1 report.html#52)

Similarly: Left assign, right assign and compare ( :=, =:, =) are also not "Algol68" Operators.

Pointers are not operators per se. There are a few "identity relations" associated with pointers: e.g. :=:, :/=:, IS & ISNT

c.f. Assignation and identity relations etc.

(Or - if you are a language lawyer c.f. Algol 68 r1 report.html#5221)

MAR is memory address register. MDR is memory data register. These are registers part of the control unit (CU) in your cpu.

The word kentahten means in future land in Iroquois. The Iroquois lived in New York State. The Iroquois were farmers.

If you want to do it neat and effortless, you may use enums.

public class MyClass {

private enum VOWELS { A,E,I,O,U,a,e,i,o,u; }

public static void main(String []ar) {

String s = "Hello World";

for(VOWELS c : VOWELS.values())

s = s.replace(c.name(), "*");

System.out.println(s);

}

}

.

Ram

Nguye n Lo c. Bi nh has written:

'Ta m trang ho ng'

programming language called Short Code

#include <stdio.h>

int main()

{

int n;

char ch;

scanf("%d", &n);

{

scanf("%c", &ch);

ch-=32;

}

printf("%c", ch);

return 0;

}