fuxino/project-euler-solutions
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add more solutions in C

Browse Source 
Added solutions for problem 51, 52, 53, 54 and 55 in C.
This commit is contained in:
daniele 2019-09-25 17:43:40 +02:00
parent 4ac079286e
commit f017e59241
Signed by: fuxino
GPG Key ID: 6FE25B4A3EE16FDA
8 changed files with 2194 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
C/p051.c Normal file
View File

@ -0,0 +1,131 @@
/* By replacing the 1st digit of the 2-digit number *3, it turns out that six of the nine possible values: 13, 23, 43, 53, 73, and 83, are all prime.
*
* By replacing the 3rd and 4th digits of 56**3 with the same digit, this 5-digit number is the first example having seven primes among the ten
* generated numbers, yielding the family: 56003, 56113, 56333, 56443, 56663, 56773, and 56993. Consequently 56003, being the first member of this
* family, is the smallest prime with this property.
*
* Find the smallest prime which, by replacing part of the number (not necessarily adjacent digits) with the same digit, is part of an eight prime
* value family.*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include "projecteuler.h"
#define N 1000000
int count_digit(int n, int d);
int replace(int n);
int *primes;
int main(int argc, char **argv)
{
int i, found = 0;
double elapsed;
struct timespec start, end;
clock_gettime(CLOCK_MONOTONIC, &start);
/* N set to 1000000 as a reasonable limit, which turns out to be enough.*/
primes = sieve(N);
/* Checking only odd numbers with at least 4 digits.*/
for(i = 1001; !found && i < N; i += 2)
{
/* The family of numbers needs to have at least one of 0, 1 or 2 as
* repeated digits, otherwise we can't get a 8 number family (there
* are only 7 other digits). Also, the number of repeated digits must
* be 3, otherwise at least 3 resulting numbers will be divisible by 3.
* So the smaller number of this family must have three 0s, three 1s or
* three 2s.*/
if(count_digit(i, 0) >= 3 || count_digit(i, 1) >= 3 ||
count_digit(i, 2) >= 3)
{
/* If i is prime, try replacing digits, if obtaining 8 primes, then
* this is the result.*/
if(primes[i] && replace(i) == 8)
{
found = 1;
}
}
}
free(primes);
clock_gettime(CLOCK_MONOTONIC, &end);
elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
printf("Project Euler, Problem 51\n");
printf("Answer: %d\n", i-2);
printf("Elapsed time: %.9lf seconds\n", elapsed);
return 0;
}
int count_digit(int n, int d)
{
int count = 0;
while(n > 0)
{
if(n % 10 == d)
{
count++;
}
n /= 10;
}
return count;
}
int replace(int n)
{
int i, j, k, w, l, count, max = 0, s_to_n;
char n_to_s[7];
sprintf(n_to_s, "%d", n);
l = strlen(n_to_s);
for(i = 0; i < l - 3; i++)
{
for(j = i + 1; j < l - 2; j++)
{
/* Replacing the last digit can't give 8 primes, because at least
* six of the numbers obtained will be divisible by 2 and/or 5.*/
for(k = j + 1; k < l - 1; k++)
{
count = 0;
for(w = 0; w < 10; w++)
{
if(i == 0 && w == 0)
continue;
sprintf(n_to_s, "%d", n);
n_to_s[i] = w + '0';
n_to_s[j] = w + '0';
n_to_s[k] = w + '0';
s_to_n = atoi(n_to_s);
if(primes[s_to_n])
{
if(count == 0 && s_to_n != n)
continue;
count++;
}
}
if(count > max)
max = count;
}
}
}
return max;
}

74
C/p052.c Normal file
View File

@ -0,0 +1,74 @@
/* It can be seen that the number, 125874, and its double, 251748, contain exactly the same digits, but in a different order.
*
* Find the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and 6x, contain the same digits.*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int have_same_digits(int a, int b);
int main(int argc, char **argv)
{
int i, found = 0;
double elapsed;
struct timespec start, end;
clock_gettime(CLOCK_MONOTONIC, &start);
i = 1;
/* Brute force approach, try every integer number until the desired one is found.*/
while(!found)
{
if(have_same_digits(i, 2*i) && have_same_digits(i, 3*i) && have_same_digits(i, 4*i) &&
have_same_digits(i, 5*i) && have_same_digits(i, 6*i))
{
found = 1;
}
i++;
}
clock_gettime(CLOCK_MONOTONIC, &end);
elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
printf("Project Euler, Problem 52\n");
printf("Answer: %d\n", i);
printf("Elapsed time: %.9lf seconds\n", elapsed);
return 0;
}
int have_same_digits(int a, int b)
{
int i;
int digits1[10] = {0}, digits2[10] = {0};
/* Get digits of a.*/
while(a > 0)
{
digits1[a%10]++;
a /= 10;
}
/* Get digits of b.*/
while(b > 0)
{
digits2[b%10]++;
b /= 10;
}
/* If they're not the same, return 0.*/
for(i = 0; i < 10; i++)
{
if(digits1[i] != digits2[i])
{
return 0;
}
}
return 1;
}

84
C/p053.c Normal file
View File

@ -0,0 +1,84 @@
/* There are exactly ten ways of selecting three from five, 12345:
*
* 123, 124, 125, 134, 135, 145, 234, 235, 245, and 345
*
* In combinatorics, we use the notation, (5 3) = 10.
*
* In general, (n r)=n!/(r!(n−r)!), where r≤n, n!=n×(n−1)×...×3×2×1, and 0!=1.
*
* It is not until n=23, that a value exceeds one-million: (23 10)=1144066.
*
* How many, not necessarily distinct, values of (n r) for 1≤n≤100, are greater than one-million?*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <gmp.h>
#define N 100
#define LIMIT 1000000
void binomial(mpz_t bin, unsigned long int n, unsigned long int k, mpz_t *factorials);
int main(int argc, char **argv)
{
int i, j, count = 0;
double elapsed;
struct timespec start, end;
mpz_t bin;
mpz_t factorials[N+1];
clock_gettime(CLOCK_MONOTONIC, &start);
mpz_init(bin);
mpz_init_set_ui(factorials[0], 1);
/* Straightforward brute force approach, using the GMP Library. First
* calculate all factorials, then use them for the binomial coefficients.*/
for(i = 1; i <= N; i++)
{
mpz_init(factorials[i]);
mpz_fac_ui(factorials[i], i);
}
for(i = 23; i <= N; i++)
{
for(j = 1; j <= i; j++)
{
binomial(bin, i, j, factorials);
if(mpz_cmp_ui(bin, LIMIT) > 0)
count++;
}
}
mpz_clear(bin);
clock_gettime(CLOCK_MONOTONIC, &end);
elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
printf("Project Euler, Problem 53\n");
printf("Answer: %d\n", count);
printf("Elapsed time: %.9lf seconds\n", elapsed);
return 0;
}
void binomial(mpz_t bin, unsigned long n, unsigned long int k, mpz_t *factorials)
{
mpz_t num, d1, d2;
mpz_inits(num, d1, d2, NULL);
mpz_set(num, factorials[n]);
mpz_set(d1, factorials[k]);
mpz_set(d2, factorials[n-k]);
mpz_mul(d1, d1, d2);
mpz_tdiv_q(bin, num, d1);
mpz_clears(num, d1, d2, NULL);
}

771
C/p054.c Normal file
View File

@ -0,0 +1,771 @@
/* In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way:
*
* High Card: Highest value card.
* One Pair: Two cards of the same value.
* Two Pairs: Two different pairs.
* Three of a Kind: Three cards of the same value.
* Straight: All cards are consecutive values.
* Flush: All cards of the same suit.
* Full House: Three of a kind and a pair.
* Four of a Kind: Four cards of the same value.
* Straight Flush: All cards are consecutive values of same suit.
* Royal Flush: Ten, Jack, Queen, King, Ace, in same suit.
* The cards are valued in the order:
* 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King, Ace.
*
* If two players have the same ranked hands then the rank made up of the highest value wins; for example, a pair of eights beats a pair of fives
* (see example 1 below). But if two ranks tie, for example, both players have a pair of queens, then highest cards in each hand are compared
* (see example 4 below); if the highest cards tie then the next highest cards are compared, and so on.
*
* Consider the following five hands dealt to two players:
*
* Hand Player 1 Player 2 Winner
* 1 5H 5C 6S 7S KD 2C 3S 8S 8D TD Player 2
* Pair of Fives Pair of Eights
*
* 2 5D 8C 9S JS AC 2C 5C 7D 8S QH Player 1
* Highest card Ace Highest card Queen
*
* 3 2D 9C AS AH AC 3D 6D 7D TD QD Player 2
* Three Aces Flush with Diamonds
*
* 4 4D 6S 9H QH QC 3D 6D 7H QD QS Player 1
* Pair of Queens Pair of Queens
* Highest card Nine Highest card Seven
*
* 5 2H 2D 4C 4D 4S 3C 3D 3S 9S 9D Player 1
* Full House Full House
* With Three Fours With Three Threes
*
* The file, poker.txt, contains one-thousand random hands dealt to two players. Each line of the file contains ten cards
* (separated by a single space): the first five are Player 1's cards and the last five are Player 2's cards.
* You can assume that all hands are valid (no invalid characters or repeated cards), each player's hand is in no specific order,
* and in each hand there is a clear winner.
*
* How many hands does Player 1 win?*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "projecteuler.h"
/* Define the values of the cards.*/
typedef enum{two, three, four, five, six, seven, eight, nine, ten, jack, queen, king, ace} values;
/* Define a structure for a card, with value and suit.*/
typedef struct card
{
values value;
char suit;
}Card;
int eval(char *hands);
int main(int argc, char **argv)
{
int i, count = 0;
double elapsed;
char **hands;
FILE *fp;
struct timespec start, end;
clock_gettime(CLOCK_MONOTONIC, &start);
if((fp = fopen("poker.txt", "r")) == NULL)
{
fprintf(stderr, "Error while opening file %s\n", "poker.txt");
return 1;
}
if((hands = (char **)malloc(1000*sizeof(char *))) == NULL)
{
fprintf(stderr, "Error while allocating memory\n");
return 1;
}
for(i=0; i<1000; i++)
{
if((hands[i] = (char *)malloc(31*sizeof(char))) == NULL)
{
fprintf(stderr, "Error while allocating memory\n");
return 1;
}
}
for(i = 0; i < 1000; i++)
{
fgets(hands[i], 31*sizeof(char), fp);
/* Count how many hands player 1 wins, using an evaluation function.*/
if(eval(hands[i]) > 0)
{
count++;
}
free(hands[i]);
}
fclose(fp);
free(hands);
clock_gettime(CLOCK_MONOTONIC, &end);
elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
printf("Project Euler, Problem 54\n");
printf("Answer: %d\n", count);
printf("Elapsed time: %.9lf seconds\n", elapsed);
return 0;
}
int compare(void *card1, void *card2)
{
Card *c1, *c2;
c1 = (Card *)card1;
c2 = (Card *)card2;
return c1->value - c2->value;
}
void get_value(Card *card, char value)
{
if(value == '2')
{
card->value = two;
}
else if(value == '3')
{
card->value = three;
}
else if(value == '4')
{
card->value = four;
}
else if(value == '5')
{
card->value = five;
}
else if(value == '6')
{
card->value = six;
}
else if(value == '7')
{
card->value = seven;
}
else if(value == '8')
{
card->value = eight;
}
else if(value == '9')
{
card->value = nine;
}
else if(value == 'T')
{
card->value = ten;
}
else if(value == 'J')
{
card->value = jack;
}
else if(value == 'Q')
{
card->value = queen;
}
else if(value == 'K')
{
card->value = king;
}
else if(value == 'A')
{
card->value = ace;
}
}
int eval(char *hands)
{
int i, straightflush1 = 0, straightflush2 = 0, four1 = 0, four2 = 0, full1 = 0, full2 = 0, flush1 = 0, flush2 = 0;
int straight1 = 0, straight2 = 0, three1 = 0, three2 = 0, twopairs1 = 0, twopairs2 = 0;
int pair1 = 0, pair2 = 0;
char *card;
Card **cards1, **cards2;
values value;
if((cards1 = (Card **)malloc(5*sizeof(Card *))) == NULL ||
(cards2 = (Card **)malloc(5*sizeof(Card *))) == NULL)
{
fprintf(stderr, "Error while allocating memory\n");
exit(1);
}
for(i = 0; i < 5; i++)
{
if((cards1[i] = (Card *)malloc(sizeof(Card))) == NULL ||
(cards2[i] = (Card *)malloc(sizeof(Card))) == NULL)
{
fprintf(stderr, "Error while allocating memory\n");
exit(1);
}
}
card = strtok(hands, " ");
/* Get current hand for player 1.*/
get_value(cards1[0], card[0]);
cards1[0]->suit = card[1];
for(i = 1; i < 5; i++)
{
card = strtok(NULL, " ");
get_value(cards1[i], card[0]);
cards1[i]->suit = card[1];
}
/* Get current hand for player 2.*/
for(i = 0; i < 5; i++)
{
card = strtok(NULL, " ");
get_value(cards2[i], card[0]);
cards2[i]->suit = card[1];
}
/* Sort the two hands by value of the cards to make the evaluation easier.*/
insertion_sort((void **)cards1, 0, 4, compare);
insertion_sort((void **)cards2, 0, 4, compare);
/* If player 1 has a Royal Flush, player 1 wins.*/
if(cards1[4]->value == ace && cards1[3]->value == king && cards1[2]->value == queen &&
cards1[1]->value == jack && cards1[0]->value == ten && cards1[0]->suit == cards1[1]->suit &&
cards1[0]->suit == cards1[2]->suit && cards1[0]->suit == cards1[3]->suit &&
cards1[0]->suit == cards1[4]->suit)
{
return 1;
}
/* If player 2 has a Royal Flush, player 2 wins.*/
if(cards2[4]->value == ace && cards2[3]->value == king && cards2[2]->value == queen &&
cards2[1]->value == jack && cards2[0]->value == ten && cards2[0]->suit == cards2[1]->suit &&
cards2[0]->suit == cards2[2]->suit && cards2[0]->suit == cards2[3]->suit &&
cards2[0]->suit == cards2[4]->suit)
{
return -1;
}
/* Check if player 1 has a straight flush.*/
if(cards1[0]->suit == cards1[1]->suit && cards1[0]->suit == cards1[2]->suit && cards1[0]->suit == cards1[3]->suit &&
cards1[0]->suit == cards1[4]->suit)
{
value = cards1[0]->value;
for(i = 1; i < 5; i++)
{
if(++value != cards1[i]->value)
{
break;
}
}
if(i == 5)
{
straightflush1=1;
}
}
/* Check if player 2 has a straight flush.*/
if(cards2[0]->suit == cards2[1]->suit && cards2[0]->suit == cards2[2]->suit &&
cards2[0]->suit == cards2[3]->suit && cards2[0]->suit == cards2[4]->suit)
{
value = cards2[0]->value;
for(i = 1; i < 5; i++)
{
if(++value != cards2[i]->value)
{
break;
}
}
if(i == 5)
{
straightflush2=1;
}
}
/* If player 1 has a straight flush and player 2 doesn't, player 1 wins.*/
if(straightflush1 && !straightflush2)
{
return 1;
}
/* If player 2 has a straight flush and player 1 doesn't, player 2 wins.*/
if(!straightflush1 && straightflush2)
{
return -1;
}
/* If both players have a straight flush, the one with the highest value wins.
* Any card can be compared, because in the straight flush the values are consecutive
* by definition.*/
if(straightflush1 && straightflush2)
{
if(cards1[0]->value > cards2[0]->value)
{
return 1;
}
else
{
return -1;
}
}
/* Check if player 1 has a four of a kind.*/
if((cards1[0]->value == cards1[1]->value && cards1[0]->value == cards1[2]->value && cards1[0]->value == cards1[3]->value) ||
(cards1[1]->value == cards1[2]->value && cards1[1]->value == cards1[3]->value && cards1[1]->value == cards1[4]->value))
{
four1 = 1;
}
/* Check if player 2 has a four of a kind.*/
if((cards2[0]->value == cards2[1]->value && cards2[0]->value == cards2[2]->value && cards2[0]->value == cards2[3]->value) ||
(cards2[1]->value == cards2[2]->value && cards2[1]->value == cards2[3]->value && cards2[1]->value == cards2[4]->value))
{
four2 = 1;
}
/* If player 1 has four of a kind and player 2 doesn't, player 1 wins.*/
if(four1 && !four2)
{
return 1;
}
/* If player 2 has four of a kind and player 1 doesn't, player 2 wins.*/
if(!four1 && four2)
{
return -1;
}
/* If both players have four of a kind, check who has the highest value for
* those four cards. If they are equal, check the higest value for the different
* card.*/
if(four1 && four2)
{
if(cards1[1]->value > cards2[1]->value)
{
return 1;
}
else if(cards1[1]->value < cards2[1]->value)
{
return -1;
}
else
{
for(i = 4; i <= 0; i--)
{
if(cards1[i]->value > cards2[i]->value)
{
return 1;
}
if(cards1[i]->value < cards2[i]->value)
{
return -1;
}
}
}
}
/* Check if player 1 has a full house.*/
if(cards1[0]->value == cards1[1]->value && cards1[1]->value == cards1[2]->value &&
cards1[1]->value == cards1[3]->value && cards1[1]->value == cards1[4]->value)
{
full1 = 1;
}
/* Check if player 2 has a full house.*/
if(cards2[0]->value == cards2[1]->value && cards2[1]->value == cards2[2]->value &&
cards2[1]->value == cards2[3]->value && cards2[1]->value == cards2[4]->value)
{
full2 = 1;
}
/* If player 1 has a full house and player 2 doesn't, player 1 wins.*/
if(full1 && !full2)
{
return 1;
}
/* If player 2 has a full house and player 1 doesn't, player 2 wins.*/
if(!full1 && full2)
{
return -1;
}
/* If both players have a full house, check who has the highest value
* for the three equal cards (the third card in the array will be part
* of the set of three). If they are equal, check the highest value
* for the other two cards.*/
if(full1 && full2)
{
if(cards1[2]->value > cards2[2]->value)
{
return 1;
}
if(cards1[2]->value < cards2[2]->value)
{
return -1;
}
for(i = 4; i >= 0; i--)
{
if(cards1[i]->value > cards2[i]->value)
{
return 1;
}
if(cards1[i]->value < cards2[i]->value)
{
return -1;
}
}
}
/* Check if player 1 has a flush.*/
if(cards1[0]->suit == cards1[1]->suit && cards1[0]->suit == cards1[2]->suit &&
cards1[0]->suit == cards1[3]->suit && cards1[0]->suit == cards1[4]->suit)
{
flush1 = 1;
}
/* Check if player 2 has a flush.*/
if(cards2[0]->suit == cards2[1]->suit && cards2[0]->suit == cards2[2]->suit &&
cards2[0]->suit == cards2[3]->suit && cards2[0]->suit == cards2[4]->suit)
{
flush2 = 1;
}
/* If player 1 has a flush and player 2 doesn't, player 1 wins.*/
if(flush1 && !flush2)
{
return 1;
}
/* If player 2 has a flush and player 1 doesn't, player 2 wins.*/
if(!flush1 && flush2)
{
return -1;
}
/* If both players have a flush, check who has the highest card, if
* the highest is equal check the second highest and so on.*/
if(flush1 && flush2)
{
for(i = 4; i <= 0; i--)
{
if(cards1[i]->value > cards2[i]->value)
{
return 1;
}
if(cards1[i]->value < cards2[i]->value)
{
return -1;
}
}
}
/* Check if player 1 has a straight.*/
value = cards1[0]->value;
for(i = 1; i < 5; i++)
{
if(++value != cards1[i]->value)
{
break;
}
}
if(i == 5)
{
straight1 = 1;
}
/* Check if player 2 has a straight.*/
value = cards2[0]->value;
for(i = 1; i < 5; i++)
{
if(++value != cards2[i]->value)
{
break;
}
}
if(i == 5)
{
straight2 = 1;
}
/* If player 1 has a straight and player 2 doesn't, player 1 wins.*/
if(straight1 && !straight2)
{
return 1;
}
/* If player 2 has a straight and player 1 doesn't, player 2 wins.*/
if(!straight1 && straight2)
{
return -1;
}
/* If both players have a straight, check who has the highest card.*/
if(straight1 && straight2)
{
if(cards1[4]->value > cards2[4]->value)
{
return 1;
}
else
{
return -1;
}
}
/* Check if player 1 has three of a kind.*/
if((cards1[0]->value == cards1[1]->value && cards1[0]->value == cards1[2]->value) ||
(cards1[1]->value == cards1[2]->value && cards1[1]->value == cards1[3]->value) ||
(cards1[2]->value == cards1[3]->value && cards1[2]->value == cards1[4]->value))
{
three1 = 1;
}
/* Check if player 2 has three of a kind.*/
if((cards2[0]->value == cards2[1]->value && cards2[0]->value == cards2[2]->value) ||
(cards2[1]->value == cards2[2]->value && cards2[1]->value == cards2[3]->value) ||
(cards2[2]->value == cards2[3]->value && cards2[2]->value == cards2[4]->value))
{
three2 = 1;
}
/* If player 1 has three of a kind and player 2 doesn't, player 1 wins.*/
if(three1 && !three2)
{
return 1;
}
/* If player 2 has three of a kind and player 1 doesn't, player 2 wins.*/
if(!three1 && three2)
{
return -1;
}
/* If both players have three of a kind, check who has the highest value for
* these three cards. If it's equal, check who has the highest value for the
* other cards.*/
if(three1 && three2)
{
if(cards1[2]->value > cards2[2]->value)
{
return 1;
}
if(cards1[2]->value < cards2[2]->value)
{
return -1;
}
for(i = 4; i <= 0; i--)
{
if(cards1[i]->value > cards2[i]->value)
{
return 1;
}
if(cards1[i]->value < cards2[i]->value)
{
return -1;
}
}
}
/* Check if player 1 has two pairs.*/
if((cards1[0]->value == cards1[1]->value && cards1[2]->value == cards1[3]->value) ||
(cards1[0]->value == cards1[1]->value && cards1[3]->value == cards1[4]->value) ||
(cards1[1]->value == cards1[2]->value && cards1[3]->value == cards1[4]->value))
{
twopairs1 = 1;
}
/* Check if player 2 has two pairs.*/
if((cards2[0]->value == cards2[1]->value && cards2[2]->value == cards2[3]->value) ||
(cards2[0]->value == cards2[1]->value && cards2[3]->value == cards2[4]->value) ||
(cards2[1]->value == cards2[2]->value && cards2[3]->value == cards2[4]->value))
{
twopairs2 = 1;
}
/* If player 1 has two pairs and player 2 doesn't, player 1 wins.*/
if(twopairs1 && !twopairs2)
{
return 1;
}
/* If player 2 has two pairs and player 1 doesn't, player 2 wins.*/
if(!twopairs1 && twopairs2)
{
return -1;
}
/* If both players have two pairs, check who has the highest pair. If it's equal,
* check the other pair. If it's still equal, check the remaining card.*/
if(twopairs1 && twopairs2)
{
if(cards1[3]->value > cards2[3]->value)
{
return 1;
}
if(cards1[3]->value < cards2[3]->value)
{
return -1;
}
if(cards1[1]->value > cards2[1]->value)
{
return 1;
}
if(cards1[1]->value < cards2[1]->value)
{
return -1;
}
for(i = 4; i <= 0; i--)
{
if(cards1[i]->value > cards2[i]->value)
{
return 1;
}
if(cards1[i]->value < cards2[i]->value)
{
return -1;
}
}
}
/* Check if player 1 has a pair.*/
if(cards1[0]->value == cards1[1]->value || cards1[1]->value == cards1[2]->value ||
cards1[2]->value == cards1[3]->value || cards1[3]->value == cards1[4]->value)
{
pair1 = 1;
}
/* Check if player 2 has a pair.*/
if(cards2[0]->value == cards2[1]->value || cards2[1]->value == cards2[2]->value ||
cards2[2]->value == cards2[3]->value || cards2[3]->value == cards2[4]->value)
{
pair2 = 1;
}
/* If player 1 has a pair and player 2 doesn't, player 1 wins.*/
if(pair1 && !pair2)
{
return 1;
}
/* If player 2 has a pair and player 1 doesn't, player 2 wins.*/
if(!pair1 && pair2)
{
return -1;
}
/* If both players have a pair, check who has the highest pair. Since the cards are
* ordered by value, either card[1] will be part of the pair (card[0]=card[1] or
* card[1]=card[2]) or card[3] will be part of the pair (card[2]=card[3] or
* card[3]=card[4]). */
if(pair1 && pair2)
{
if(cards1[0]->value == cards1[1]->value || cards1[1]->value == cards1[2]->value)
{
value = cards1[1]->value;
if(cards2[0]->value == cards2[1]->value || cards2[1]->value == cards2[2]->value)
{
if(value > cards2[1]->value)
{
return 1;
}
if(value < cards2[1]->value)
{
return -1;
}
}
if(cards2[2]->value == cards2[3]->value || cards2[3]->value == cards2[4]->value)
{
if(value > cards2[3]->value)
{
return 1;
}
if(value < cards2[3]->value)
{
return -1;
}
}
}
else
{
value = cards1[3]->value;
if(cards2[0]->value == cards2[1]->value || cards2[1]->value == cards2[2]->value)
{
if(value > cards2[1]->value)
{
return 1;
}
if(value < cards2[1]->value)
{
return -1;
}
}
if(cards2[2]->value == cards2[3]->value || cards2[3]->value == cards2[4]->value)
{
if(value > cards2[3]->value)
{
return 1;
}
if(value < cards2[3]->value)
{
return -1;
}
}
}
}
/* If the players have the same pair, or if both don't have a pair, check who has
* the highest card, if it's equal check the second highest and so on.*/
for(i = 4; i >= 0; i--)
{
if(cards1[i]->value > cards2[i]->value)
{
return 1;
}
if(cards1[i]->value < cards2[i]->value)
{
return -1;
}
}
return 0;
}

103
C/p055.c Normal file
View File

@ -0,0 +1,103 @@
/* If we take 47, reverse and add, 47 + 74 = 121, which is palindromic.
*
* Not all numbers produce palindromes so quickly. For example,
*
* 349 + 943 = 1292,
* 1292 + 2921 = 4213
* 4213 + 3124 = 7337
*
* That is, 349 took three iterations to arrive at a palindrome.
*
* Although no one has proved it yet, it is thought that some numbers, like 196, never produce a palindrome. A number that never forms a palindrome
* through the reverse and add process is called a Lychrel number. Due to the theoretical nature of these numbers, and for the purpose of this problem,
* we shall assume that a number is Lychrel until proven otherwise. In addition you are given that for every number below ten-thousand, it will either
* (i) become a palindrome in less than fifty iterations, or,
* (ii) no one, with all the computing power that exists, has managed so far to map it to a palindrome. In fact, 10677 is the first number to be shown
* to require over fifty iterations before producing a palindrome: 4668731596684224866951378664 (53 iterations, 28-digits).
*
* Surprisingly, there are palindromic numbers that are themselves Lychrel numbers; the first example is 4994.
*
* How many Lychrel numbers are there below ten-thousand?
*
* NOTE: Wording was modified slightly on 24 April 2007 to emphasise the theoretical nature of Lychrel numbers.*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <gmp.h>
#include "projecteuler.h"
int is_lychrel(mpz_t n);
int main(int argc, char **argv)
{
int i, count = 0;
double elapsed;
struct timespec start, end;
mpz_t n;
clock_gettime(CLOCK_MONOTONIC, &start);
mpz_init(n);
/* For each number, use the is_lychrel function to check if the number
* is a Lychrel number.*/
for(i = 1; i < 10000; i++)
{
mpz_set_ui(n, i);
if(is_lychrel(n))
count++;
}
mpz_clear(n);
clock_gettime(CLOCK_MONOTONIC, &end);
elapsed = (end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1000000000;
printf("Project Euler, Problem 55\n");
printf("Answer: %d\n", count);
printf("Elapsed time: %.9lf seconds\n", elapsed);
return 0;
}
int is_lychrel(mpz_t n)
{
int i;
mpz_t tmp, reverse, rem;
mpz_inits(tmp, reverse, rem, NULL);
mpz_set(tmp, n);
/* Run for 50 iterations.*/
for(i = 0; i < 50; i++)
{
mpz_set_ui(reverse, 0);
/* Find the reverse of the given number.*/
while(mpz_cmp_ui(tmp, 0) > 0)
{
mpz_mul_ui(reverse, reverse, 10);
mpz_tdiv_qr_ui(tmp, rem, tmp, 10);
mpz_add(reverse, reverse, rem);
}
/* Add the reverse to the original number.*/
mpz_add(tmp, n, reverse);
/* If the sum is a palindrome, the number is not a Lychrel number.*/
if(is_palindrome_mpz(tmp, 10))
{
mpz_clears(tmp, reverse, rem, NULL);
return 0;
}
mpz_set(n, tmp);
}
mpz_clears(tmp, reverse, rem, NULL);
return 1;
}

1000
C/poker.txt Normal file
View File

File diff suppressed because it is too large Load Diff

28
C/projecteuler.c
View File

@ -1,6 +1,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gmp.h>
#include "projecteuler.h"
int partition(void **array, int l, int r, int (*cmp)(void *lv, void *rv));
@ -69,6 +70,33 @@ int is_palindrome(int num, int base)
return 0;
}
/* Same function, using GMP Library for long numbers.*/
int is_palindrome_mpz(mpz_t num, int base)
{
mpz_t tmp, reverse, rem;
mpz_inits(tmp, reverse, rem, NULL);
mpz_set(tmp, num);
mpz_set_ui(reverse, 0);
while(mpz_cmp_ui(tmp, 0) > 0)
{
mpz_mul_ui(reverse, reverse, base);
mpz_tdiv_qr_ui(tmp, rem, tmp, base);
mpz_add(reverse, reverse, rem);
}
if(!mpz_cmp(num, reverse))
{
mpz_clears(reverse, rem, NULL);
return 1;
}
mpz_clears(reverse, rem, NULL);
return 0;
}
long int gcd(long int a, long int b)
{
/* Euclid's algorithm for the greatest common divisor:

3
C/projecteuler.h
View File

@ -1,8 +1,11 @@
#ifndef _PROJECTEULER_INCLUDED
#define _PROJECTEULER_INCLUDED
#include <gmp.h>
int is_prime(long int);
int is_palindrome(int num, int base);
int is_palindrome_mpz(mpz_t n, int base);
long int gcd(long int a, long int b);
long int lcm(long int a, long int b);
long int lcmm(long int *values, int n);