Tail Function

void monster::monstermove(player * player1) {
if(abs(player1->m_x - m_x) < 10 && abs(player1->m_y - m_y) < 10)
return;
if(!CanMove())
return;
float tangent;
m_yvel = 4;
m_xvel=4;
if(abs(player1->m_y - this->m_y) < 10) m_yvel=0;
if(abs(player1->m_x - this->m_x) < 10) m_xvel=0;
tangent = (player1->m_y - this->m_y) / (player1->m_x - this->m_x) ;
this->m_yvel *= (abs(sinf(atan(tangent))));
this->m_xvel *= (abs(cosf(atan(tangent))));
if(player1->m_x - this->m_x > 0 && player1->m_y - this->m_y < 0) {
m_yvel*=-1;
}else if(player1->m_x - this->m_x < 0 && player1->m_y - this->m_y> 0) {
m_xvel*=-1;
}else if(player1->m_x - this->m_x < 0 && player1->m_y - this->m_y< 0) {
m_yvel*=-1;
m_xvel*=-1;
}
this->m_y += m_yvel;
this->m_x += m_xvel; //* (player1->m_x - this->m_x>0 && m_xvel >0 ?1:-1);
}

SDL Library - Tetris Game

#include "SDL.h"
#include "glut.h"
#include <iostream>
#include <string>
#include <Windows.h>
#include <SDL_opengl.h>
#include "ball.h"
#include <SDL_image.h>
struct brick{
  float x;
  float y;
  float width;
  float height;
  bool alive;
};
GLuint loadTexture( const std::string &fileName )
{
  SDL_Surface *image = IMG_Load( fileName.c_str() );

  SDL_DisplayFormatAlpha(image);

  unsigned object(0);

  glGenTextures(1, &object);

  glBindTexture(GL_TEXTURE_2D, object);

  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->w, image->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixels);

  //Free surface
  SDL_FreeSurface(image);

  return object;
}
bool iscollission(float ballx,float bally,float ballH,float ballL,float ourx,float oury,float ourH,float ourL);
int main( int argc, char* args[] )
{
  //initialize SDL
  SDL_Init(SDL_INIT_EVERYTHING);

  //Set OpenGL memory usage
  SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 );
  SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8);
  SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8 );
  SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 8);
  SDL_GL_SetAttribute( SDL_GL_BUFFER_SIZE, 32);
  SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );

  //Caption of the window
  SDL_WM_SetCaption( "Our first game", NULL );

  //Size of the window
  SDL_SetVideoMode(600,400,32, SDL_OPENGL );

  //Specific the clear color
  glClearColor(1,1,1,1); //RED,GREEN,BLUE,ALPHA

  //What portion of the screen we will display
  glViewport(0,0,600,400);

  //Shader model - Use this
  glShadeModel(GL_SMOOTH);

  //2D rendering
  glMatrixMode(GL_PROJECTION);

  //"Save" it
  glLoadIdentity();

  //Disable depth checking
  glDisable(GL_DEPTH_TEST);

  std::cout << "OpenGL is running\n";
  std::cout << "Main loop has started\n";

  //Handles the main loop
  bool isRunning = true;

  //For handling with event
  SDL_Event event;

  float myX = 300; //starting x position of rectangle
  float myY = 370; //starting y position of rectangle
  float width = 80; //width of the rectangle
  float height = 20; //height of the rectangle

  bool left = false,right = false; //we save in which state the button is

  //The ball variables
  float ballX = 50; //x position
  float ballY = 150;    //y position
  float ballWH = 30; //width and height of the ball

  float vellX = 0.2; //x speed
  float vellY = 0.2; //y speed

  const int brCOUNT = 45;
  brick bricks[brCOUNT];

  for(int i=0,x=4,y=4;i<brCOUNT;i++,x+=66) {
 if(x>560) {
x=4;
y+=30;
 }
 bricks[i].x = x; //Set currents bricks x position
      bricks[i].y = y; //Y position
      bricks[i].width = 60; //Width
      bricks[i].height = 20; //Heigh
 bricks[i].alive = true;
  }

  //Create an texture
  unsigned int pad_texture = 0;
  //Load the image into the texture using the function
  pad_texture = loadTexture("line.png");
  //Main game loop
  while ( isRunning )
    {
       //EVENTS
      while ( SDL_PollEvent(&event) )
        {
          //if the window was closed
          if ( event.type == SDL_QUIT )
            {
              isRunning = false;
            }

          //If a button was released and the button is escape
          if ( event.type == SDL_KEYUP && event.key.keysym.sym == SDLK_ESCAPE )
            {
              isRunning = false;
            }

          if ( event.type == SDL_KEYUP && event.key.keysym.sym == SDLK_r )
            {
              glClearColor(1,0,0,1);
            }

          if ( event.type == SDL_KEYDOWN ) //Check for presed down buttons
            {
              if ( event.key.keysym.sym == SDLK_LEFT ) //Check left key
                {
                  left = true; //Set the boolean value for left key to true (it is pressed)
                }

              else if ( event.key.keysym.sym == SDLK_RIGHT ) //Check Right key
                {
                  right = true; //Set the boolean value for right key to true (it is pressed)
                }
             
            }

          else if ( event.type == SDL_KEYUP ) //Checking for released buttons
            {
              if ( event.key.keysym.sym == SDLK_LEFT ) //Left key
                {
                  left = false; //Set the value to false (key is released)
                }
           
              else if ( event.key.keysym.sym == SDLK_RIGHT ) //Right key
                {
                  right = false; //Key is released
                }
            }

          //logic that should happen for a certain event
        }

      //LOGIC
      if ( left == true ) //If left key is pressed
        {
          myX -= 0.5; //Move left
        }

      if ( right == true ) //If right key is pressed
        {
          myX += 0.5; //Move right
        }

      if ( myX < 0 ) //If the left border of the pad is over the left part of the screen
        {
          myX = 0; //Put the pad back so it isn't over the border
        }

      if ( myX+width > 600 ) //If the pad is over the right border of the screen
        {
          myX = 600-width; //Move it back so it only touches the right border
        }

      //The ball logic
      ballX += vellX; //Move the ball on x axis
      ballY += vellY; //move the ball on y axis

      if ( ballX < 0 ) //Check if the ball hit the left edge of screen
        {
          vellX = -vellX; //negate the x velocity
        }

      else if ( ballX+ballWH>600 )
        {
          vellX = -vellX;
        }

      if ( ballY < 0 )
        {
          vellY = -vellY;
        }

      else if ( ballY+ballWH > 400 ) //if the ball hit the bottom edge of screen
        {
          isRunning = false; //close game
        }
 if(iscollission(ballX,ballY,ballWH,ballWH,myX,myY,height,width)) {
 vellY = -vellY;
 }
 for(int i=0;i<brCOUNT;i++) {
 if(bricks[i].alive) {
 if(iscollission(bricks[i].x,bricks[i].y,bricks[i].height,bricks[i].width,ballX,ballY,ballWH,ballWH)) {
 bricks[i].alive = false;
 vellY = -vellY;
 break;
 }
 }

 }

       //RENDERING to the screen
      glClear(GL_COLOR_BUFFER_BIT);

      glPushMatrix(); //Start rendering phase

      glOrtho(0,600,400,0,-1,1); //Set the matrix

      glColor4ub(255,255,255,255); //White color

      //Enable textures when we are going to blend an texture
      glEnable(GL_TEXTURE_2D);
      //What texture we are going to use
      glBindTexture(GL_TEXTURE_2D,pad_texture);

      glBegin(GL_QUADS); //Start drawing the pad

      //We set the corners of the texture using glTexCoord2d
      glTexCoord2d(0,0); glVertex2f(myX,myY); //Upper-left corner
      glTexCoord2d(1,0); glVertex2f(myX+width,myY); //Upper-right corner
      glTexCoord2d(1,1); glVertex2f(myX+width,myY+height); //Down-right corner
      glTexCoord2d(0,1); glVertex2f(myX,myY+height); //Down-left corner

      glEnd(); //End drawing

      glColor4ub(255,0,0,255); //Red color

      glBegin(GL_QUADS); //Render of the ball, same method as for the pad
      glVertex2f(ballX,ballY);
      glVertex2f(ballX+ballWH,ballY);
      glVertex2f(ballX+ballWH,ballY+ballWH);
      glVertex2f(ballX,ballY+ballWH);
      glEnd();
      for(int i=0;i<brCOUNT;i++) {
 if(bricks[i].alive != true) continue;
if(i%9==0)  glColor4ub(i*5,i*5,0,1);
  glBegin(GL_QUADS);
      glVertex2f(bricks[i].x,bricks[i].y);
      glVertex2f(bricks[i].x+bricks[i].width,bricks[i].y);
      glVertex2f(bricks[i].x+bricks[i].width,bricks[i].y+bricks[i].height);
      glVertex2f(bricks[i].x,bricks[i].y+bricks[i].height);
      glEnd();

 }
      glPopMatrix(); //End rendering phase

      SDL_GL_SwapBuffers();

      SDL_Delay(1); //Delay / pause
    }

  SDL_Quit();

  return 0;
}

bool iscollission(float ballx,float bally,float ballH,float ballW,float ourx,float oury,float ourH,float ourW) {
if(bally+ballH < oury) return false;
else if(ourx>ballx+ballW) return false;
else if(ourx+ourW < ballx) return false;
else if(oury+ourH < bally) return false;
return true;
}

Current getDate seperate by seperate

#include "stdafx.h"
#include <iostream>
#include <windows.h>
#include <string>
#include <ctime>

using namespace std;
 int         getMonth(time_t timeval){
 struct tm * timeinfo;
 timeinfo = localtime(&timeval);
 return timeinfo->tm_mon + 1;
}
int         getDay(time_t timeval){
 struct tm * timeinfo;
 timeinfo = localtime(&timeval);
 return timeinfo->tm_mday;
}
int         getYear(time_t timeval){
 struct tm * timeinfo;
 timeinfo = localtime(&timeval);
 return timeinfo->tm_year+1900;
}
int         getHour(time_t timeval){
 struct tm * timeinfo;
 timeinfo = localtime(&timeval);
 return timeinfo->tm_hour;
}
int         getMin(time_t timeval){
 struct tm * timeinfo;
 timeinfo = localtime(&timeval);
 return timeinfo->tm_min;
}
int         getSec(time_t timeval){
 struct tm * timeinfo;
 timeinfo = localtime(&timeval);
 return timeinfo->tm_sec;
}
string getWeekday(time_t timeval){
  struct tm * timeinfo;
  string days[7] = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
    //could just make this global

  timeinfo = localtime(&timeval);

  return days[timeinfo->tm_wday];
}
string getmonth(time_t timeval){
  struct tm * timeinfo;
  string days[12] = {"January","February","March","April","May","June","July","August","September","October","November","December"};
    //could just make this global

  timeinfo = localtime(&timeval);

  return days[timeinfo->tm_mon];
}

int main()
{

 /*time_t rawtime;
  struct tm * timeinfo;

  time (&rawtime);
  timeinfo = localtime (&rawtime);
  printf ("Current local time and date: %s", asctime(timeinfo));
  */


cout << "Date :" << getMonth(time(0)) << "/" <<  getDay(time(0)) << "/" << getYear(time(0)) << "-" << getWeekday(time(0)) << "\nClock:" << getHour(time(0)) << ":" << getMin(time(0)) << ":" << getSec(time(0)) << endl ;

system("pause");
return 0;
}

XOX Game

    Multiplayer Game

                                                                   
                                                                     Single Game
                         

                                                      ----------main.cpp --------

#include "stdafx.h"
#include <iostream>
#include "efe.h"
#include <ctime>
using namespace std;
int main()
{
mainscreen();
system("pause");
return 0;
}

                                          -----------efe.h---------

#include "stdafx.h"
#include <iostream>
#include <ctime>
#include <windows.h>
using namespace std;
void computer(char player,char computer);
void sender(char player);
void multiplayer(char playerone);
void checkermulti();
void show(char dizi[3][3],char turn);
void checker(char dizi[3][3],char computer,char player);
char dizi[3][3],efee;int turn=0;
bool efe=1,mltplyr=0;
void mainscreen() {
srand(time(NULL));
system("cls");
for(int i=0;i<3;i++) {
for(int k=0;k<3;k++) {
dizi[i][k] = '-';
}
}
char choosee[10];
char choose;
string str;
cout << "                  ############################################" << "\n" << "                  #" << "          XOX Game Version 1.0.0          " << "#\n" << "                  #" << "            Written by 0xhex              " << "#\n" "                  ############################################" << "\n";
cout << "If you want to play with computer press 1" << endl;
cout << "If you want to play with your friend press 2" << endl; cin >> choose;
if(choose==49) {
cout << "Which do you prefer X or O" << endl;
do {
cin >> choosee;
choose=choosee[0];
if(choose!='X' && choose!='O') cout << "Enter X or O" << endl;
}while(choose!='X' && choose!='O');
if(choose=='X') {
show(dizi,choose);
do {computer('X','O'); }while(efe==1);
}else {
show(dizi,choose);
do {computer('O','X'); }while(efe==1);
}
}else if(choose==50) {
cout << "Player-one,what will be?  X or O:";
do {
cin >> choose;
if(choose!='X' && choose!='O') cout << "Enter X or O" << endl;
}while(choose!='X' && choose!='O');
multiplayer(choose);

}else {
system("cls");
mainscreen();
}
}
void sender(char player) {
int row,coloumn;
bool res=0;
cout << endl;
do {
do {
cout << "                           Which row?(1,2,3) :" ;
cin >> row;
if(row!=1 && row!=2 && row!=3) cout << "Please enter number between 0 and 4 (1,2,3)";
}while(row!=1 && row!=2 && row!=3);

do {
cout << "                           Which coloumn?(1,2,3) :";
cin >> coloumn;
if(coloumn!=1 && coloumn!=2 && coloumn!=3) cout << "Please enter number between 0 and 4 (1,2,3)";
}while(coloumn!=1 && coloumn!=2 && coloumn!=3);
if(dizi[row-1][coloumn-1]=='-') {
dizi[row-1][coloumn-1]=player;
break;
}else {
cout << "                           This area full please enter another choose" << endl;
}
}while(true);//player turn over here!!!

if(dizi[0][0]!='-' && dizi[0][1]!='-' && dizi[0][2]!='-' && dizi[1][0]!='-' && dizi[1][1]!='-' && dizi[1][2]!='-' && dizi[2][0]!='-' && dizi[2][1]!='-' && dizi[2][2]!='-') {
    efe=0;
show(dizi,player);
cout << "                           No Winner!" << endl;
cout << "                           Do you wanna play again? (y/n)" << endl;
int x;
do {
cout << "                           ";
cin >> x;
if(x==0) {    exit(0);     };
if(x!=1 && x!=0) { cout << "                           please enter 1 or 0" << endl; }else {
if(x==1) {      mainscreen();  break;}
}
}while(x!=1 && x!=0);
}


}

void computer(char player,char computer) {
sender(player);
checker(dizi,computer,player);    //turn is computer
show(dizi,player);
if(efe==0) {
cout << "                           Winner Computer" << endl;
cout << "                           Do you wanna play again?(again:1-exit:0)" << endl;
int x;
do {
cout << "                           ";
cin >> x;
if(x==0) {    exit(0);     };
if(x!=1 && x!=0) { cout << "                           please enter 1 or 0" << endl; }else {
if(x==1) {      mainscreen();  break;}
}
}while(x!=1 && x!=0);
}
turn++;
}

void show(char dizi[3][3],char player) {
cout << endl;
cout << "                              " << "1  " << "2  " << "3" << endl;
for(int i=0;i<3;i++) {
cout << "                            ";
if(i==0) cout << "1";
if(i==1) cout << "2";
if(i==2) cout << "3";
for(int k=0;k<3;k++) {
if(dizi[i][k]=='-') {
cout << "[" << dizi[i][k] << "]";
}else {
cout << "[" << dizi[i][k] << "]";
}
}
cout << endl;
}
if(efe==1) {
cout << endl;
cout << "                           Turn is " << player << ";";
}
}
void checker(char dizi[3][3],char computer,char player) {
if(turn==0) {           //if first round and middle is empty ; give &computer into middle
if(dizi[1][1]=='-') {
dizi[1][1]=computer;
return;
        }
           }
      if(dizi[1][1]==dizi[0][2] && dizi[1][1]==computer && dizi[2][0] == '-') { dizi[2][0] = computer;   efe=0; return;
}else if(dizi[1][1]==dizi[2][0] && dizi[1][1]==computer && dizi[0][2] == '-') { dizi[0][2] = computer;        efe=0;   return;
}else if(dizi[2][0]==dizi[0][2] && dizi[2][0]==computer && dizi[1][1] == '-') {  dizi[1][1] = computer;        efe=0;  return;
}else if(dizi[1][1]==dizi[0][0] && dizi[1][1]==computer && dizi[2][2] == '-') {  dizi[2][2] = computer;         efe=0; return;
}else if(dizi[1][1]==dizi[2][2] && dizi[1][1]==computer && dizi[0][0] == '-') {  dizi[0][0] = computer;          efe=0;return;
}else if(dizi[0][0]==dizi[2][2] && dizi[2][2]==computer && dizi[1][1] == '-') {  dizi[1][1] = computer;         efe=0; return;}
        for(int i=0;i<3;i++) {
if(dizi[i][0] == dizi[i][2] && dizi[i][0]==computer && dizi[i][1] =='-') { // first and third check //row checker here!!!
dizi[i][1] = computer;  efe=0; return;
}else if(dizi[i][0] == dizi[i][1] && dizi[i][1]==computer && dizi[i][2] =='-') {   // first and second check
dizi[i][2] = computer;  efe=0; return;
}else if(dizi[i][1] == dizi[i][2] && dizi[i][1]==computer && dizi[i][0] =='-') {   // second and third check
dizi[i][0] = computer; efe=0; return;
}
}
    for(int i=0;i<3;i++) {
if(dizi[0][i] == dizi[2][i] && dizi[0][i]==computer && dizi[1][i] =='-') { // first and third check        //coloumn checker here!!!
dizi[1][i] =computer;  efe=0 ; return;
}else if(dizi[0][i] == dizi[1][i] && dizi[1][i]==computer && dizi[2][i] =='-') {   // first and second check
dizi[2][i] =computer;   efe=0;return;
}else if(dizi[1][i] == dizi[2][i] && dizi[1][i]==computer && dizi[0][i] =='-') {   // second and third check
dizi[0][i] =computer;  efe=0;return;
}
}
      if(dizi[1][1]==dizi[0][2] && dizi[1][1]==player && dizi[2][0] == '-') {  dizi[2][0] = computer; return;
}else if(dizi[1][1]==dizi[2][0] && dizi[1][1]==player && dizi[0][2] == '-') {  dizi[0][2] = computer; return;  
}else if(dizi[2][0]==dizi[0][2] && dizi[2][0]==player && dizi[1][1] == '-') {  dizi[1][1] = computer; return;
}else if(dizi[1][1]==dizi[0][0] && dizi[1][1]==player && dizi[2][2] == '-') {  dizi[2][2] = computer; return;
}else if(dizi[1][1]==dizi[2][2] && dizi[1][1]==player && dizi[0][0] == '-') {  dizi[0][0] = computer;  return;
}else if(dizi[0][0]==dizi[2][2] && dizi[2][2]==player && dizi[1][1] == '-') {  dizi[1][1] = computer; return;  }

    for(int i=0;i<3;i++) {
if((dizi[i][0] == dizi[i][2]) && dizi[i][0]==player && dizi[i][1] =='-') { // first and third check //row checker here!!!
dizi[i][1]=computer; return;
}else if((dizi[i][0] == dizi[i][1]) && dizi[i][1]==player && dizi[i][2] =='-') {   // first and second check
dizi[i][2] =computer; return;
}else if((dizi[i][1] == dizi[i][2]) && dizi[i][1]==player && dizi[i][0] =='-') {   // second and third check
dizi[i][0] =computer; return;
}
}

    for(int i=0;i<3;i++) {
if((dizi[0][i] == dizi[2][i]) && dizi[0][i]==player && dizi[1][i] =='-') { // first and third check        //coloumn checker here!!!
dizi[1][i] =computer; return;
}else if((dizi[0][i] == dizi[1][i]) && dizi[1][i]==player && dizi[2][i] =='-') {   // first and second check
dizi[2][i] =computer; return;
}else if((dizi[1][i] == dizi[2][i]) && dizi[1][i]==player && dizi[0][i] =='-') {   // second and third check
dizi[0][i] =computer;return;
}
}
int x=0,y=0;
do{
x=rand()%3;  Sleep(35);
y=rand()%3;
if(dizi[x][y]=='-') {
dizi[x][y]=computer;
break;
return;
}
}while(true);

}
void multiplayer(char playerone) {
char playertwo;
if(playerone=='X') {
playertwo='O';
}else {
playertwo='X';
}
do {
if(turn%2==0) {
    show(dizi,playerone);
sender(playerone);
checkermulti();
}else{
show(dizi,playertwo);
sender(playertwo);
checkermulti();
}
turn++;
}while(efe==1);
        show(dizi,playertwo);             // there is winner and last show last situation
  if(efee==3) {

  cout << "                           No Winner!" << endl;
  }else {
cout << "                           Winner " << efee << "!" << endl;
  }
cout << "                           Do you wanna play again?(again:1-exit:0)" << endl;
int x;
do {
cout << "                           ";
cin >> x;
if(x==0) {    exit(0);     };
if(x!=1 && x!=0) { cout << "                           please enter 1 or 0" << endl; }else {
if(x==1) {      mainscreen();  break;}
}
}while(x!=1 && x!=0);
}
void checkermulti() {
 for(int i=0,k=0;i<3;i++) {
 if(dizi[i][k] == dizi[i][k+1] && dizi[i][k+1] == dizi[i][k+2] && dizi[i][k+1] != '-') {       //from right to left
//Winner
 efe=0;
efee=dizi[i][k];
return;
 }
 }
  for(int i=0,k=0;i<3;i++) {
 if(dizi[k][i] == dizi[k+1][i] && dizi[k+1][i] == dizi[k+2][i] && dizi[k+1][i] != '-') {     //from up to down
  //Winner
 efe=0;
efee=dizi[k][i];
return;
 }
 }
 if(dizi[1][1] == dizi[2][0] && dizi[1][1] == dizi[0][2] && dizi[1][1] != '-') {         //cross
 //Winner
efe=0;
efee=dizi[1][1];
return;
 }

  if(dizi[1][1] == dizi[0][0] && dizi[1][1] == dizi[2][2] && dizi[1][1] != '-') {   //cross
 //Winner
        efe=0;
efee=dizi[1][1];
return;
 }
  if(dizi[0][0]!='-' && dizi[0][1]!='-' && dizi[0][2]!='-' && dizi[1][0]!='-' && dizi[1][1]!='-' && dizi[1][2]!='-' && dizi[2][0]!='-' && dizi[2][1]!='-' && dizi[2][2]!='-') {
  efe=0;
  efee=3;
  }
};

Fourty nineth solution of Project Euler - Prime permutations

Click and See Problem 49

#include "stdafx.h"
#include <iostream>
#include<stdio.h>
#include <cmath>
#include <time.h>
using namespace std;
bool prime(unsigned long long y);

bool prime(unsigned long long y) {
 for (unsigned long long i = 3; i <= (int) sqrt((double) y); i++) {
 if (y % i == 0)
 return 0;
 }
 return 1;
}
bool issamedigit(int x,int y) {
int seq[4],seqq[4];
 int c=0;
 do {
seq[c]=x%10;
  x/=10;
  c++;
 }while(x>0);
 c=0;
  do {
seqq[c]=y%10;
  y/=10;
  c++;
 }while(y>0);

for(int i=0;i<4;i++) {
if(seq[i]!=seqq[0] && seq[i]!=seqq[1] && seq[i]!=seqq[2] && seq[i]!=seqq[3]) {
return 0;
}
}

for(int i=0;i<4;i++) {
if(seqq[i]!=seq[0] && seqq[i]!=seq[1] && seqq[i]!=seq[2] && seqq[i]!=seq[3]) {
return 0;
}
}
 return 1;
}
void make() {
for(int i=1001;i<9999;i+=2) {
if(prime(i)==1)  {
for(int k=i+2;k<9999;k+=2) {
if(prime(k)==1 && issamedigit(i,k)==1) {
int m=k+(k-i);
if(m<9999 && prime(m)==1 && issamedigit(k,m)==1 && i>2000) {
cout << "Project Euler - Problem 49(Prime permutations)\n";
                   cout << "Result :" <<i << k << m << " efekanpulatli.blogspot.com" << endl;
  return;

}
}
}
}
}
}
int main() {
clock_t tStart = clock();
make();
    printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
 system("pause");
return 0;
}

Fortieth solution of Project Euler - Champernowne's constant

Click and See Problem 40

#include "stdafx.h"
#include <iostream>
#include<stdio.h>
#include <cmath>
#include <time.h>
using namespace std;
int digit(int y) {
 int c=0;
 do {
  y/=10;
  c++;
 }while(y>0);

 return c;
}
void make() {
int c,k=-1,m,counter=0;
int dizi[10];
dizi[6] = 0;
for(int i=1;i<900000;i++) {
if(dizi[6]!=0) break;
c=i;
m=0;
k+=digit(i);
do {
if((k-m)+1==1 || (k-m)+1==10 || (k-m)+1 == 100 || (k-m)+1==1000 || (k-m)+1==10000 || (k-m)+1==100000 || (k-m)+1==1000000) {
dizi[counter]=c%10;
counter++;
}
c/=10;
m++;
}while(c>0);

}
int result=1;
for(int i=0;i<7;i++) {
result*=dizi[i];
}
cout << "Project Euler - Problem 40(Champernowne's constant)\n";
  cout << "Result :" <<result << " efekanpulatli.blogspot.com" << endl;
}
int main() {
clock_t tStart = clock();
  make();
    printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
 system("pause");
return 0;
}

Fourty sixth solution of Project Euler - Goldbach's other conjecture

Click and See Problem 46

#include "stdafx.h"
#include <iostream>
#include<stdio.h>
#include <cmath>
#include "efe.h"
#include <time.h>
using namespace std;
bool prime(unsigned long long y);

bool prime(unsigned long long y) {
 for (unsigned long long i = 3; i <= (int) sqrt((double) y); i++) {
 if (y % i == 0)
 return false;
 }
 return true;
}

void make() {
int c,lim=0,dizi[10000];
dizi[0]=2;
for(int i=3;i<10000;i+=2){
if(prime(i)==1) {
dizi[lim] = i;
lim++;
}
}
int k=0;
double kare;

    for(int i=11;i<10000;i+=2) {
bool efe=0;
if(prime(i)!=1) {
k=0;
do {
c=i;
c-=dizi[k];
k++;
if(c%2==1) {
                continue;
}
c/=2;
kare = sqrt((double) c);
kare = ((int)kare);
if(c/kare==sqrt((long double) c)) {
           efe=1;
break;
}

}while(c>0);
if(efe==0) {
cout << "Project Euler - Problem 46(Goldbach's other conjecture)\n";
                cout << "Result :" <<i << " efekanpulatli.blogspot.com" << endl;
break;
}
}
}

}
int main() {
clock_t tStart = clock();
          make();
    printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
 system("pause");
return 0;
}

Fourty second solution of Project Euler - Coded triangle numbers

Click and See Problem 42

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <ctime>
using namespace std;

void make() {
int dizi[45],result=0;
for(int i=0;i<35;i++) {
dizi[i]=((i+1)*(i+2))/2;
}
int res=0;
string efe[2000] = {"A","ABILITY","ABLE","ABOUT","ABOVE","ABSENCE","ABSOLUTELY","ACADEMIC","ACCEPT","ACCESS","ACCIDENT","ACCOMPANY","ACCORDING","ACCOUNT","ACHIEVE","ACHIEVEMENT","ACID","ACQUIRE","ACROSS","ACT","ACTION","ACTIVE","ACTIVITY","ACTUAL","ACTUALLY","ADD","ADDITION","ADDITIONAL","ADDRESS","ADMINISTRATION","ADMIT","ADOPT","ADULT","ADVANCE","ADVANTAGE","ADVICE","ADVISE","AFFAIR","AFFECT","AFFORD","AFRAID","AFTER","AFTERNOON","AFTERWARDS","AGAIN","AGAINST","AGE","AGENCY","AGENT","AGO","AGREE","AGREEMENT","AHEAD","AID","AIM","AIR","AIRCRAFT","ALL","ALLOW","ALMOST","ALONE","ALONG","ALREADY","ALRIGHT","ALSO","ALTERNATIVE","ALTHOUGH","ALWAYS","AMONG","AMONGST","AMOUNT","AN","ANALYSIS","ANCIENT","AND","ANIMAL","ANNOUNCE","ANNUAL","ANOTHER","ANSWER","ANY","ANYBODY","ANYONE","ANYTHING","ANYWAY","APART","APPARENT","APPARENTLY","APPEAL","APPEAR","APPEARANCE","APPLICATION","APPLY","APPOINT","APPOINTMENT","APPROACH","APPROPRIATE","APPROVE","AREA","ARGUE","ARGUMENT","ARISE","ARM","ARMY","AROUND","ARRANGE","ARRANGEMENT","ARRIVE","ART","ARTICLE","ARTIST","AS","ASK","ASPECT","ASSEMBLY","ASSESS","ASSESSMENT","ASSET","ASSOCIATE","ASSOCIATION","ASSUME","ASSUMPTION","AT","ATMOSPHERE","ATTACH","ATTACK","ATTEMPT","ATTEND","ATTENTION","ATTITUDE","ATTRACT","ATTRACTIVE","AUDIENCE","AUTHOR","AUTHORITY","AVAILABLE","AVERAGE","AVOID","AWARD","AWARE","AWAY","AYE","BABY","BACK","BACKGROUND","BAD","BAG","BALANCE","BALL","BAND","BANK","BAR","BASE","BASIC","BASIS","BATTLE","BE","BEAR","BEAT","BEAUTIFUL","BECAUSE","BECOME","BED","BEDROOM","BEFORE","BEGIN","BEGINNING","BEHAVIOUR","BEHIND","BELIEF","BELIEVE","BELONG","BELOW","BENEATH","BENEFIT","BESIDE","BEST","BETTER","BETWEEN","BEYOND","BIG","BILL","BIND","BIRD","BIRTH","BIT","BLACK","BLOCK","BLOOD","BLOODY","BLOW","BLUE","BOARD","BOAT","BODY","BONE","BOOK","BORDER","BOTH","BOTTLE","BOTTOM","BOX","BOY","BRAIN","BRANCH","BREAK","BREATH","BRIDGE","BRIEF","BRIGHT","BRING","BROAD","BROTHER","BUDGET","BUILD","BUILDING","BURN","BUS","BUSINESS","BUSY","BUT","BUY","BY","CABINET","CALL","CAMPAIGN","CAN","CANDIDATE","CAPABLE","CAPACITY","CAPITAL","CAR","CARD","CARE","CAREER","CAREFUL","CAREFULLY","CARRY","CASE","CASH","CAT","CATCH","CATEGORY","CAUSE","CELL","CENTRAL","CENTRE","CENTURY","CERTAIN","CERTAINLY","CHAIN","CHAIR","CHAIRMAN","CHALLENGE","CHANCE","CHANGE","CHANNEL","CHAPTER","CHARACTER","CHARACTERISTIC","CHARGE","CHEAP","CHECK","CHEMICAL","CHIEF","CHILD","CHOICE","CHOOSE","CHURCH","CIRCLE","CIRCUMSTANCE","CITIZEN","CITY","CIVIL","CLAIM","CLASS","CLEAN","CLEAR","CLEARLY","CLIENT","CLIMB","CLOSE","CLOSELY","CLOTHES","CLUB","COAL","CODE","COFFEE","COLD","COLLEAGUE","COLLECT","COLLECTION","COLLEGE","COLOUR","COMBINATION","COMBINE","COME","COMMENT","COMMERCIAL","COMMISSION","COMMIT","COMMITMENT","COMMITTEE","COMMON","COMMUNICATION","COMMUNITY","COMPANY","COMPARE","COMPARISON","COMPETITION","COMPLETE","COMPLETELY","COMPLEX","COMPONENT","COMPUTER","CONCENTRATE","CONCENTRATION","CONCEPT","CONCERN","CONCERNED","CONCLUDE","CONCLUSION","CONDITION","CONDUCT","CONFERENCE","CONFIDENCE","CONFIRM","CONFLICT","CONGRESS","CONNECT","CONNECTION","CONSEQUENCE","CONSERVATIVE","CONSIDER","CONSIDERABLE","CONSIDERATION","CONSIST","CONSTANT","CONSTRUCTION","CONSUMER","CONTACT","CONTAIN","CONTENT","CONTEXT","CONTINUE","CONTRACT","CONTRAST","CONTRIBUTE","CONTRIBUTION","CONTROL","CONVENTION","CONVERSATION","COPY","CORNER","CORPORATE","CORRECT","COS","COST","COULD","COUNCIL","COUNT","COUNTRY","COUNTY","COUPLE","COURSE","COURT","COVER","CREATE","CREATION","CREDIT","CRIME","CRIMINAL","CRISIS","CRITERION","CRITICAL","CRITICISM","CROSS","CROWD","CRY","CULTURAL","CULTURE","CUP","CURRENT","CURRENTLY","CURRICULUM","CUSTOMER","CUT","DAMAGE","DANGER","DANGEROUS","DARK","DATA","DATE","DAUGHTER","DAY","DEAD","DEAL","DEATH","DEBATE","DEBT","DECADE","DECIDE","DECISION","DECLARE","DEEP","DEFENCE","DEFENDANT","DEFINE","DEFINITION","DEGREE","DELIVER","DEMAND","DEMOCRATIC","DEMONSTRATE","DENY","DEPARTMENT","DEPEND","DEPUTY","DERIVE","DESCRIBE","DESCRIPTION","DESIGN","DESIRE","DESK","DESPITE","DESTROY","DETAIL","DETAILED","DETERMINE","DEVELOP","DEVELOPMENT","DEVICE","DIE","DIFFERENCE","DIFFERENT","DIFFICULT","DIFFICULTY","DINNER","DIRECT","DIRECTION","DIRECTLY","DIRECTOR","DISAPPEAR","DISCIPLINE","DISCOVER","DISCUSS","DISCUSSION","DISEASE","DISPLAY","DISTANCE","DISTINCTION","DISTRIBUTION","DISTRICT","DIVIDE","DIVISION","DO","DOCTOR","DOCUMENT","DOG","DOMESTIC","DOOR","DOUBLE","DOUBT","DOWN","DRAW","DRAWING","DREAM","DRESS","DRINK","DRIVE","DRIVER","DROP","DRUG","DRY","DUE","DURING","DUTY","EACH","EAR","EARLY","EARN","EARTH","EASILY","EAST","EASY","EAT","ECONOMIC","ECONOMY","EDGE","EDITOR","EDUCATION","EDUCATIONAL","EFFECT","EFFECTIVE","EFFECTIVELY","EFFORT","EGG","EITHER","ELDERLY","ELECTION","ELEMENT","ELSE","ELSEWHERE","EMERGE","EMPHASIS","EMPLOY","EMPLOYEE","EMPLOYER","EMPLOYMENT","EMPTY","ENABLE","ENCOURAGE","END","ENEMY","ENERGY","ENGINE","ENGINEERING","ENJOY","ENOUGH","ENSURE","ENTER","ENTERPRISE","ENTIRE","ENTIRELY","ENTITLE","ENTRY","ENVIRONMENT","ENVIRONMENTAL","EQUAL","EQUALLY","EQUIPMENT","ERROR","ESCAPE","ESPECIALLY","ESSENTIAL","ESTABLISH","ESTABLISHMENT","ESTATE","ESTIMATE","EVEN","EVENING","EVENT","EVENTUALLY","EVER","EVERY","EVERYBODY","EVERYONE","EVERYTHING","EVIDENCE","EXACTLY","EXAMINATION","EXAMINE","EXAMPLE","EXCELLENT","EXCEPT","EXCHANGE","EXECUTIVE","EXERCISE","EXHIBITION","EXIST","EXISTENCE","EXISTING","EXPECT","EXPECTATION","EXPENDITURE","EXPENSE","EXPENSIVE","EXPERIENCE","EXPERIMENT","EXPERT","EXPLAIN","EXPLANATION","EXPLORE","EXPRESS","EXPRESSION","EXTEND","EXTENT","EXTERNAL","EXTRA","EXTREMELY","EYE","FACE","FACILITY","FACT","FACTOR","FACTORY","FAIL","FAILURE","FAIR","FAIRLY","FAITH","FALL","FAMILIAR","FAMILY","FAMOUS","FAR","FARM","FARMER","FASHION","FAST","FATHER","FAVOUR","FEAR","FEATURE","FEE","FEEL","FEELING","FEMALE","FEW","FIELD","FIGHT","FIGURE","FILE","FILL","FILM","FINAL","FINALLY","FINANCE","FINANCIAL","FIND","FINDING","FINE","FINGER","FINISH","FIRE","FIRM","FIRST","FISH","FIT","FIX","FLAT","FLIGHT","FLOOR","FLOW","FLOWER","FLY","FOCUS","FOLLOW","FOLLOWING","FOOD","FOOT","FOOTBALL","FOR","FORCE","FOREIGN","FOREST","FORGET","FORM","FORMAL","FORMER","FORWARD","FOUNDATION","FREE","FREEDOM","FREQUENTLY","FRESH","FRIEND","FROM","FRONT","FRUIT","FUEL","FULL","FULLY","FUNCTION","FUND","FUNNY","FURTHER","FUTURE","GAIN","GAME","GARDEN","GAS","GATE","GATHER","GENERAL","GENERALLY","GENERATE","GENERATION","GENTLEMAN","GET","GIRL","GIVE","GLASS","GO","GOAL","GOD","GOLD","GOOD","GOVERNMENT","GRANT","GREAT","GREEN","GREY","GROUND","GROUP","GROW","GROWING","GROWTH","GUEST","GUIDE","GUN","HAIR","HALF","HALL","HAND","HANDLE","HANG","HAPPEN","HAPPY","HARD","HARDLY","HATE","HAVE","HE","HEAD","HEALTH","HEAR","HEART","HEAT","HEAVY","HELL","HELP","HENCE","HER","HERE","HERSELF","HIDE","HIGH","HIGHLY","HILL","HIM","HIMSELF","HIS","HISTORICAL","HISTORY","HIT","HOLD","HOLE","HOLIDAY","HOME","HOPE","HORSE","HOSPITAL","HOT","HOTEL","HOUR","HOUSE","HOUSEHOLD","HOUSING","HOW","HOWEVER","HUGE","HUMAN","HURT","HUSBAND","I","IDEA","IDENTIFY","IF","IGNORE","ILLUSTRATE","IMAGE","IMAGINE","IMMEDIATE","IMMEDIATELY","IMPACT","IMPLICATION","IMPLY","IMPORTANCE","IMPORTANT","IMPOSE","IMPOSSIBLE","IMPRESSION","IMPROVE","IMPROVEMENT","IN","INCIDENT","INCLUDE","INCLUDING","INCOME","INCREASE","INCREASED","INCREASINGLY","INDEED","INDEPENDENT","INDEX","INDICATE","INDIVIDUAL","INDUSTRIAL","INDUSTRY","INFLUENCE","INFORM","INFORMATION","INITIAL","INITIATIVE","INJURY","INSIDE","INSIST","INSTANCE","INSTEAD","INSTITUTE","INSTITUTION","INSTRUCTION","INSTRUMENT","INSURANCE","INTEND","INTENTION","INTEREST","INTERESTED","INTERESTING","INTERNAL","INTERNATIONAL","INTERPRETATION","INTERVIEW","INTO","INTRODUCE","INTRODUCTION","INVESTIGATE","INVESTIGATION","INVESTMENT","INVITE","INVOLVE","IRON","IS","ISLAND","ISSUE","IT","ITEM","ITS","ITSELF","JOB","JOIN","JOINT","JOURNEY","JUDGE","JUMP","JUST","JUSTICE","KEEP","KEY","KID","KILL","KIND","KING","KITCHEN","KNEE","KNOW","KNOWLEDGE","LABOUR","LACK","LADY","LAND","LANGUAGE","LARGE","LARGELY","LAST","LATE","LATER","LATTER","LAUGH","LAUNCH","LAW","LAWYER","LAY","LEAD","LEADER","LEADERSHIP","LEADING","LEAF","LEAGUE","LEAN","LEARN","LEAST","LEAVE","LEFT","LEG","LEGAL","LEGISLATION","LENGTH","LESS","LET","LETTER","LEVEL","LIABILITY","LIBERAL","LIBRARY","LIE","LIFE","LIFT","LIGHT","LIKE","LIKELY","LIMIT","LIMITED","LINE","LINK","LIP","LIST","LISTEN","LITERATURE","LITTLE","LIVE","LIVING","LOAN","LOCAL","LOCATION","LONG","LOOK","LORD","LOSE","LOSS","LOT","LOVE","LOVELY","LOW","LUNCH","MACHINE","MAGAZINE","MAIN","MAINLY","MAINTAIN","MAJOR","MAJORITY","MAKE","MALE","MAN","MANAGE","MANAGEMENT","MANAGER","MANNER","MANY","MAP","MARK","MARKET","MARRIAGE","MARRIED","MARRY","MASS","MASTER","MATCH","MATERIAL","MATTER","MAY","MAYBE","ME","MEAL","MEAN","MEANING","MEANS","MEANWHILE","MEASURE","MECHANISM","MEDIA","MEDICAL","MEET","MEETING","MEMBER","MEMBERSHIP","MEMORY","MENTAL","MENTION","MERELY","MESSAGE","METAL","METHOD","MIDDLE","MIGHT","MILE","MILITARY","MILK","MIND","MINE","MINISTER","MINISTRY","MINUTE","MISS","MISTAKE","MODEL","MODERN","MODULE","MOMENT","MONEY","MONTH","MORE","MORNING","MOST","MOTHER","MOTION","MOTOR","MOUNTAIN","MOUTH","MOVE","MOVEMENT","MUCH","MURDER","MUSEUM","MUSIC","MUST","MY","MYSELF","NAME","NARROW","NATION","NATIONAL","NATURAL","NATURE","NEAR","NEARLY","NECESSARILY","NECESSARY","NECK","NEED","NEGOTIATION","NEIGHBOUR","NEITHER","NETWORK","NEVER","NEVERTHELESS","NEW","NEWS","NEWSPAPER","NEXT","NICE","NIGHT","NO","NOBODY","NOD","NOISE","NONE","NOR","NORMAL","NORMALLY","NORTH","NORTHERN","NOSE","NOT","NOTE","NOTHING","NOTICE","NOTION","NOW","NUCLEAR","NUMBER","NURSE","OBJECT","OBJECTIVE","OBSERVATION","OBSERVE","OBTAIN","OBVIOUS","OBVIOUSLY","OCCASION","OCCUR","ODD","OF","OFF","OFFENCE","OFFER","OFFICE","OFFICER","OFFICIAL","OFTEN","OIL","OKAY","OLD","ON","ONCE","ONE","ONLY","ONTO","OPEN","OPERATE","OPERATION","OPINION","OPPORTUNITY","OPPOSITION","OPTION","OR","ORDER","ORDINARY","ORGANISATION","ORGANISE","ORGANIZATION","ORIGIN","ORIGINAL","OTHER","OTHERWISE","OUGHT","OUR","OURSELVES","OUT","OUTCOME","OUTPUT","OUTSIDE","OVER","OVERALL","OWN","OWNER","PACKAGE","PAGE","PAIN","PAINT","PAINTING","PAIR","PANEL","PAPER","PARENT","PARK","PARLIAMENT","PART","PARTICULAR","PARTICULARLY","PARTLY","PARTNER","PARTY","PASS","PASSAGE","PAST","PATH","PATIENT","PATTERN","PAY","PAYMENT","PEACE","PENSION","PEOPLE","PER","PERCENT","PERFECT","PERFORM","PERFORMANCE","PERHAPS","PERIOD","PERMANENT","PERSON","PERSONAL","PERSUADE","PHASE","PHONE","PHOTOGRAPH","PHYSICAL","PICK","PICTURE","PIECE","PLACE","PLAN","PLANNING","PLANT","PLASTIC","PLATE","PLAY","PLAYER","PLEASE","PLEASURE","PLENTY","PLUS","POCKET","POINT","POLICE","POLICY","POLITICAL","POLITICS","POOL","POOR","POPULAR","POPULATION","POSITION","POSITIVE","POSSIBILITY","POSSIBLE","POSSIBLY","POST","POTENTIAL","POUND","POWER","POWERFUL","PRACTICAL","PRACTICE","PREFER","PREPARE","PRESENCE","PRESENT","PRESIDENT","PRESS","PRESSURE","PRETTY","PREVENT","PREVIOUS","PREVIOUSLY","PRICE","PRIMARY","PRIME","PRINCIPLE","PRIORITY","PRISON","PRISONER","PRIVATE","PROBABLY","PROBLEM","PROCEDURE","PROCESS","PRODUCE","PRODUCT","PRODUCTION","PROFESSIONAL","PROFIT","PROGRAM","PROGRAMME","PROGRESS","PROJECT","PROMISE","PROMOTE","PROPER","PROPERLY","PROPERTY","PROPORTION","PROPOSE","PROPOSAL","PROSPECT","PROTECT","PROTECTION","PROVE","PROVIDE","PROVIDED","PROVISION","PUB","PUBLIC","PUBLICATION","PUBLISH","PULL","PUPIL","PURPOSE","PUSH","PUT","QUALITY","QUARTER","QUESTION","QUICK","QUICKLY","QUIET","QUITE","RACE","RADIO","RAILWAY","RAIN","RAISE","RANGE","RAPIDLY","RARE","RATE","RATHER","REACH","REACTION","READ","READER","READING","READY","REAL","REALISE","REALITY","REALIZE","REALLY","REASON","REASONABLE","RECALL","RECEIVE","RECENT","RECENTLY","RECOGNISE","RECOGNITION","RECOGNIZE","RECOMMEND","RECORD","RECOVER","RED","REDUCE","REDUCTION","REFER","REFERENCE","REFLECT","REFORM","REFUSE","REGARD","REGION","REGIONAL","REGULAR","REGULATION","REJECT","RELATE","RELATION","RELATIONSHIP","RELATIVE","RELATIVELY","RELEASE","RELEVANT","RELIEF","RELIGION","RELIGIOUS","RELY","REMAIN","REMEMBER","REMIND","REMOVE","REPEAT","REPLACE","REPLY","REPORT","REPRESENT","REPRESENTATION","REPRESENTATIVE","REQUEST","REQUIRE","REQUIREMENT","RESEARCH","RESOURCE","RESPECT","RESPOND","RESPONSE","RESPONSIBILITY","RESPONSIBLE","REST","RESTAURANT","RESULT","RETAIN","RETURN","REVEAL","REVENUE","REVIEW","REVOLUTION","RICH","RIDE","RIGHT","RING","RISE","RISK","RIVER","ROAD","ROCK","ROLE","ROLL","ROOF","ROOM","ROUND","ROUTE","ROW","ROYAL","RULE","RUN","RURAL","SAFE","SAFETY","SALE","SAME","SAMPLE","SATISFY","SAVE","SAY","SCALE","SCENE","SCHEME","SCHOOL","SCIENCE","SCIENTIFIC","SCIENTIST","SCORE","SCREEN","SEA","SEARCH","SEASON","SEAT","SECOND","SECONDARY","SECRETARY","SECTION","SECTOR","SECURE","SECURITY","SEE","SEEK","SEEM","SELECT","SELECTION","SELL","SEND","SENIOR","SENSE","SENTENCE","SEPARATE","SEQUENCE","SERIES","SERIOUS","SERIOUSLY","SERVANT","SERVE","SERVICE","SESSION","SET","SETTLE","SETTLEMENT","SEVERAL","SEVERE","SEX","SEXUAL","SHAKE","SHALL","SHAPE","SHARE","SHE","SHEET","SHIP","SHOE","SHOOT","SHOP","SHORT","SHOT","SHOULD","SHOULDER","SHOUT","SHOW","SHUT","SIDE","SIGHT","SIGN","SIGNAL","SIGNIFICANCE","SIGNIFICANT","SILENCE","SIMILAR","SIMPLE","SIMPLY","SINCE","SING","SINGLE","SIR","SISTER","SIT","SITE","SITUATION","SIZE","SKILL","SKIN","SKY","SLEEP","SLIGHTLY","SLIP","SLOW","SLOWLY","SMALL","SMILE","SO","SOCIAL","SOCIETY","SOFT","SOFTWARE","SOIL","SOLDIER","SOLICITOR","SOLUTION","SOME","SOMEBODY","SOMEONE","SOMETHING","SOMETIMES","SOMEWHAT","SOMEWHERE","SON","SONG","SOON","SORRY","SORT","SOUND","SOURCE","SOUTH","SOUTHERN","SPACE","SPEAK","SPEAKER","SPECIAL","SPECIES","SPECIFIC","SPEECH","SPEED","SPEND","SPIRIT","SPORT","SPOT","SPREAD","SPRING","STAFF","STAGE","STAND","STANDARD","STAR","START","STATE","STATEMENT","STATION","STATUS","STAY","STEAL","STEP","STICK","STILL","STOCK","STONE","STOP","STORE","STORY","STRAIGHT","STRANGE","STRATEGY","STREET","STRENGTH","STRIKE","STRONG","STRONGLY","STRUCTURE","STUDENT","STUDIO","STUDY","STUFF","STYLE","SUBJECT","SUBSTANTIAL","SUCCEED","SUCCESS","SUCCESSFUL","SUCH","SUDDENLY","SUFFER","SUFFICIENT","SUGGEST","SUGGESTION","SUITABLE","SUM","SUMMER","SUN","SUPPLY","SUPPORT","SUPPOSE","SURE","SURELY","SURFACE","SURPRISE","SURROUND","SURVEY","SURVIVE","SWITCH","SYSTEM","TABLE","TAKE","TALK","TALL","TAPE","TARGET","TASK","TAX","TEA","TEACH","TEACHER","TEACHING","TEAM","TEAR","TECHNICAL","TECHNIQUE","TECHNOLOGY","TELEPHONE","TELEVISION","TELL","TEMPERATURE","TEND","TERM","TERMS","TERRIBLE","TEST","TEXT","THAN","THANK","THANKS","THAT","THE","THEATRE","THEIR","THEM","THEME","THEMSELVES","THEN","THEORY","THERE","THEREFORE","THESE","THEY","THIN","THING","THINK","THIS","THOSE","THOUGH","THOUGHT","THREAT","THREATEN","THROUGH","THROUGHOUT","THROW","THUS","TICKET","TIME","TINY","TITLE","TO","TODAY","TOGETHER","TOMORROW","TONE","TONIGHT","TOO","TOOL","TOOTH","TOP","TOTAL","TOTALLY","TOUCH","TOUR","TOWARDS","TOWN","TRACK","TRADE","TRADITION","TRADITIONAL","TRAFFIC","TRAIN","TRAINING","TRANSFER","TRANSPORT","TRAVEL","TREAT","TREATMENT","TREATY","TREE","TREND","TRIAL","TRIP","TROOP","TROUBLE","TRUE","TRUST","TRUTH","TRY","TURN","TWICE","TYPE","TYPICAL","UNABLE","UNDER","UNDERSTAND","UNDERSTANDING","UNDERTAKE","UNEMPLOYMENT","UNFORTUNATELY","UNION","UNIT","UNITED","UNIVERSITY","UNLESS","UNLIKELY","UNTIL","UP","UPON","UPPER","URBAN","US","USE","USED","USEFUL","USER","USUAL","USUALLY","VALUE","VARIATION","VARIETY","VARIOUS","VARY","VAST","VEHICLE","VERSION","VERY","VIA","VICTIM","VICTORY","VIDEO","VIEW","VILLAGE","VIOLENCE","VISION","VISIT","VISITOR","VITAL","VOICE","VOLUME","VOTE","WAGE","WAIT","WALK","WALL","WANT","WAR","WARM","WARN","WASH","WATCH","WATER","WAVE","WAY","WE","WEAK","WEAPON","WEAR","WEATHER","WEEK","WEEKEND","WEIGHT","WELCOME","WELFARE","WELL","WEST","WESTERN","WHAT","WHATEVER","WHEN","WHERE","WHEREAS","WHETHER","WHICH","WHILE","WHILST","WHITE","WHO","WHOLE","WHOM","WHOSE","WHY","WIDE","WIDELY","WIFE","WILD","WILL","WIN","WIND","WINDOW","WINE","WING","WINNER","WINTER","WISH","WITH","WITHDRAW","WITHIN","WITHOUT","WOMAN","WONDER","WONDERFUL","WOOD","WORD","WORK","WORKER","WORKING","WORKS","WORLD","WORRY","WORTH","WOULD","WRITE","WRITER","WRITING","WRONG","YARD","YEAH","YEAR","YES","YESTERDAY","YET","YOU","YOUNG","YOUR","YOURSELF","YOUTH"};

for(int k=0;k<1975;k++) {
res=0;
string efee=efe[k];
for(int i=0;i<efee.length();i++) {
         res+=efee[i]-64;
}
for(int m=0;m<35;m++) {
if(res==dizi[m]) {
result++;
}
}
}
cout << "Project Euler - Problem 42(Coded triangle numbers)\n";
  cout << "Result :" <<result << " efekanpulatli.blogspot.com" << endl;
}
int main ()
{

    clock_t tStart = clock();
make();
printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
       system("PAUSE");
  return 0;
}

Thirty eighth solution of Project Euler - Pandigital multiples

Click and See Problem 38

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>
using namespace std;
unsigned long getpow(int y) {

 unsigned long tot=1;
 for(;y>0;y--) {
  tot*=10;
 }
 return tot;
}
int digit(int y) {
int c=0;
do {
y/=10;
c++;
}while(y>0);

return c;
}
bool ispandigit(int dizi[]) {

for(int i=0;i<9;i++) {
for(int k=0;k<9;k++) {
if(dizi[i]==dizi[k] && i!=k) {

return 0;
}
}
}
return 1;
}
void make()
{

int dizi[15],seq[9],result;
for(int i=1;i<9999;i++) {
int counter=0,k=0;
do {
if(counter >=9) {
break;
}
for(int c=1;c<8;c++) {
int m=c*i;

if(counter >=9) {
break;
}
counter+=digit(c*i);
int p=counter-1;
do {
dizi[p]=m%10;
if(dizi[p]==0) {
counter = 15;
break;
}
m/=10;
p--;

}while(m>0);
}
}while(counter<=9);
if(counter==9 && ispandigit(dizi)==1) {
memcpy(seq, dizi, sizeof dizi[0] * 9);
}
}
cout << "Project Euler - Problem 38(Pandigital multiples)\n";
  cout << "Result :" ;
for(int i=0;i<9;i++) {
cout << seq[i];
}
cout << " efekanpulatli.blogspot.com" << endl;
}
int main()
{
clock_t tStart = clock();
make();
printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
system("pause");

return 0;
}

Fourty first solution of Project Euler - Pandigital prime

Click and See Problem 41

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>
using namespace std;
unsigned long result;
bool prime(unsigned long y);
unsigned long getpow(int y);
bool prime(unsigned long y) {
 if (y % 2 == 0)
 return false;
 for (long int i = 3; i <= (long int) sqrt((double) y); i++) {
 if (y % i == 0)
 return false;
 }
 return true;
}

unsigned long getpow(int y) {

 unsigned long tot=1;
 for(;y>0;y--) {
  tot*=10;
 }
 return tot;
}


void make(int* iarr)
{
unsigned long tot=0;
tot=0;
for(int i=0; i<7; ++i) {
  tot+=iarr[i]*getpow(6-i);
 }

if(prime(tot)==1) { result=tot; }

}
int main()
{
clock_t tStart = clock();
int iarr[7] = {1,2,3,4,5,6,7};

sort(iarr,iarr+7);
make(iarr);
while(next_permutation(iarr,iarr+7))
make(iarr);
cout << "Project Euler - Problem 41(Pandigital prime)\n";
  cout << "Result :" <<result << " efekanpulatli.blogspot.com" << endl;
printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
system("pause");

return 0;
}

Fourty third solution of Project Euler - Sub-string divisibility

Click and See Problem 43

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>
using namespace std;
bool test(int dizi[]);
unsigned long getpow(int y);
unsigned long long result=0;
unsigned long getpow(int y) {

unsigned long tot=1;
for(;y>0;y--) {
tot*=10;
}


return tot;


}
void make(int* iarr)
{
if(iarr[0]==0) {
return;
}
if(iarr[3] % 2 != 0) return;
if(iarr[5] % 5 != 0) return;
unsigned long tot;
tot=iarr[9] + iarr[8]*10 + iarr[7]*100;
if(tot%17!=0) return;
tot=(tot/10) + iarr[6] * 100;
if(tot%13!=0) return;
tot=(tot/10) + iarr[5] * 100;
if(tot%11!=0) return;
tot=(tot/10) + iarr[4] * 100;
if(tot%7!=0) return;
tot=(tot/10) + iarr[3] * 100;
tot=(tot/10) + iarr[2] * 100;
if(tot%3!=0) return;
tot = 0;
for(int i=0; i<10; ++i) {
tot+=iarr[i]*getpow(9-i);
}
result+=tot;
}

int main()
{
clock_t tStart = clock();
int iarr[10] = {1,0,2,3,4,5,6,7,8,9};

sort(iarr,iarr+10);
make(iarr);
while(next_permutation(iarr,iarr+10))

make(iarr);
cout << "Project Euler - Problem 43(Sub-string divisibility)\n";
  cout << "Result :" << result << " efekanpulatli.blogspot.com" << endl;
printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
system("pause");

return 0;
}