C Programming

#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;

}

}

}

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.

/* 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;

}

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;

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;

}

A bit shift is a bitwise operation in which the bits in a value are shifted left or right.

Eight bits are 1 byte.

The word 'byte' was coined from the word "by eight" - 1 bit multiplied by 8.

My understanding is that judgements cannot be amended since they are an agreement, through the courts, that you will pay the parties the stated amount. So, another action by another court (bankrupcy) cannot override the other court's ruling. My understanding is opposite in almost all regards: First: Judgements are not an agreement, they are in fact the opposite...the finding by a court (or through a process) in an adversarial proceeding. Imposed upon the litigants, like it or not. Most any agreement, like terms of loans freely entered into, leases, supply contracts, etc., can and are altered by the bankruptcy court. That is exactly what the Court does...resolves the agreements that the debtor cannot fulfill. The Federal Bankruptcy Courts (all bankruptcies are handled in federal courts) are given very broad and far reaching powers. It can and will litigate many issues of different types if the result is needed to resolve the bankruptcy. (Or it can elect to wait for the "normal"court process..and then abide by it or not). Like any higher court, it can override the finding of a lower one. While some types of things are exempt from dismissal in bankruptcy (child support for example), many times Bankruptcy is used to essentially erase or lessen the court findings. Seen recently, even by major corporations with substantial assets, because of the results of losing large environmental clean up responsibily (asbestos, etc) and drug liability cases in particular. The huge liability would be a burden on the Co for decades. The people/communities that would have had claims under those liabilities essentially got paid much less than they would have through the bankruptcy process, and the Co may even reorganize and continue without the liability going forward.

When constructing a copyright notice for display on a protected work.

In the United States, a properly written copyright notice usually consists of three elements::

1. the © symbol (in some cases (c) is substituted), the word "Copyright" or abbreviation "Copr.";

2. the first year of publication; and

3. the owner of the copyright, either by name, abbreviation, or other designation