sigonasr2
/
ProjectEuler
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

#24 permutations complete

Browse Source 
Co-authored-by: sigonasr2 <sigonasr2@gmail.com>
main
sigonasr2, Sig, Sigo 3 years ago
parent 4fc79e56cd
commit 693ee1e4ae
6 changed files with 290 additions and 32 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. BIN
      archives/24/current
  2. 79
      archives/24/src/main.c
  3. 140
      archives/24/src/utils.c
  4. 14
      archives/24/src/utils.h
  5. BIN
      current
  6. 89
      src/main.c

BIN
archives/24/current
View File

Binary file not shown.

79
archives/24/src/main.c
Unescape View File

@ -0,0 +1,79 @@
#include <stdio.h>
#include "utils.h"
/*
A permutation is an ordered arrangement of objects. For example, 3124 is one possible permutation of the digits 1, 2, 3 and 4. If all of the permutations are listed numerically or alphabetically, we call it lexicographic order. The lexicographic permutations of 0, 1 and 2 are:
012 021 102 120 201 210
What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?
https://projecteuler.net/problem=24
*/
void carryover(int*arr,int digit) {
arr[digit]=0;
if (arr[digit-1]==9) {
carryover(arr,digit-1);
} else {
arr[digit-1]++;
}
}
void incrementDigit(int*arr) {
int val = arr[9];
if (arr[9]==9) {
carryover(arr,9);
} else {
arr[9]++;
}
}
boolean allUniqueDigits(int*arr) {
boolean digits[10] = {};
for (int i=0;i<10;i++) {
if (!digits[arr[i]]) {
digits[arr[i]]=true;
} else {
return false;
}
}
return true;
}
int factorial(int numb) {
int final=1;
for (int i=numb;i>=1;i--) {
final*=i;
}
return final;
}
int main(int argc,char**argv) {
//For permutations, we know that there are a total of N! permutations.
// Which means each individual set starts at N!/N. So we can skip ahead some permutations.
// For 10 numbers, we get 362,880 values per permutation set. So 1000000/362880 = 2. So we'll start at permutation two.
int setPermutationCount=factorial(10)/10;
int permutationCount=(1000000/setPermutationCount)*setPermutationCount;
int digits[10]={2,0,1,3,4,5,6,7,8,9};
while ((digits[0]!=9||digits[1]!=8||digits[2]!=7||digits[3]!=6||digits[4]!=5||digits[5]!=4||digits[6]!=3||digits[7]!=2||digits[8]!=1||digits[9]!=0)&&permutationCount!=999999) {
incrementDigit(digits);
if (allUniqueDigits(digits)) {
permutationCount++;
printf("%d:",permutationCount);
for (int i=0;i<10;i++) {
printf(" %d ",digits[i]);
}
printf("\n");
}
}
printf("\n\nThe one millionth lexicographic permutation is: \n\t");
for (int i=0;i<10;i++) {
printf("%d",digits[i]);
}
return 0;
}

140
archives/24/src/utils.c
Unescape View File

@ -0,0 +1,140 @@
#include "utils.h"
#include <stdio.h>
#include <stdlib.h>
struct String mult(struct String numb1, struct String numb2) {
struct String n1 = numb1;
struct String n2 = numb2;
byte carryover = 0;
if (numb2.length>numb1.length) {
n1=numb2;
n2=numb1;
}
int addends[n2.length][n1.length+1];
for (int i=0;i<n2.length;i++) {
for (int j=0;j<n1.length+1;j++) {
addends[i][j]=0;
}
}
for (int i=n2.length-1;i>=0;i--) {
carryover=0;
for (int j=n1.length-1;j>=0;j--) {
int mult = (n1.str[j]-'0')*(n2.str[i]-'0')+((carryover!=0)?carryover:0);
//printf(" %d/%d\n",mult,carryover);
carryover=0;
if (mult>=10) {
carryover=mult/10;
mult=mult%10;
}
addends[(n2.length-1)-i][j+1]=mult;
}
if (carryover>0) {
addends[(n2.length-1)-i][0]=carryover;
}
}
//printIntDoubleArr(n2.length,n1.length+1,addends);
struct String sum = {1,"0"};
for (int i=0;i<n2.length;i++) {
char val[n1.length+1+i];
for (int j=0;j<n1.length+1+i;j++) {
val[j]='0';
}
for (int j=0;j<n1.length+1;j++) {
val[j]=addends[i][j]+'0';
}
sum=add((struct String){n1.length+1+i,val},sum);
//printf("%s\n",sum.str);
}
if (sum.str[0]=='0') {
char*newStr=malloc(sum.length-1);
for (int i=1;i<sum.length;i++) {
newStr[i-1]=sum.str[i];
}
free(sum.str);
sum=(struct String){sum.length-1,newStr};
}
//printf("%s",sum.str);
return sum;
}
struct String add(struct String numb1, struct String numb2){
//printf("%s %s\n",numb1.str,numb2.str);
byte carryover=0;
int digitCount=0;
char*str = malloc(1);
//str[0]='\0';
if (numb1.length>=numb2.length) {
for (int offset=0;offset<numb1.length;offset++) {
str = realloc(str,++digitCount);
//printf("Digit count is now %d\n",digitCount);
if (numb2.length>offset) {
//printf("%c %c\n",numb1.str[numb1.length-offset-1],numb2.str[numb2.length-offset-1]);
int sum=((numb1.str[numb1.length-offset-1]-'0')+(numb2.str[numb2.length-offset-1]-'0'))+((carryover>0)?carryover--:0);
if (sum>=10) {
carryover=1;
sum-=10;
}
str[offset]=sum+'0';
} else {
str[offset]=numb1.str[numb1.length-offset-1]+((carryover>0)?carryover--:0);
}
//str[offset+1]='\0';
}
} else {
for (int offset=0;offset<numb2.length;offset++) {
str = realloc(str,++digitCount);
//printf("Digit count is now %d\n",digitCount);
if (numb1.length>offset) {
//printf("%c %c\n",numb1.str[numb1.length-offset-1],numb2.str[numb2.length-offset-1]);
int sum=((numb1.str[numb1.length-offset-1]-'0')+(numb2.str[numb2.length-offset-1]-'0'))+((carryover>0)?carryover--:0);
if (sum>=10) {
carryover=1;
sum-=10;
}
str[offset]=sum+'0';
} else {
str[offset]=numb2.str[numb2.length-offset-1]+((carryover>0)?carryover--:0);
}
//str[offset+1]='\0';
}
}
if (carryover>0) {
str = realloc(str,++digitCount);
str[digitCount-1]='1';
//str[digitCount]='\0';
}
for (int i=0;i<digitCount/2;i++) {
char c = str[i];
char c2 = str[digitCount-i-1];
str[digitCount-i-1]=c;
str[i]=c2;
}
str = realloc(str,digitCount+1);
str[digitCount]='\0';
struct String newStr = {digitCount,str};
return newStr;
}
void printLongDoubleArr(int a,int b,long doubleArr[a][b]) {
for (int i=0;i<a;i++) {
for (int j=0;j<b;j++) {
printf("%ld\t",doubleArr[i][j]);
}
printf("\n");
}
}
void printIntDoubleArr(int a,int b,int doubleArr[a][b]) {
for (int i=0;i<a;i++) {
for (int j=0;j<b;j++) {
printf("%d\t",doubleArr[i][j]);
}
printf("\n");
}
}
struct String createBigNumber(char*numb) {
int marker=0;
while (numb[marker++]!='\0');
return (struct String){marker-1,numb};
}

14
archives/24/src/utils.h
Unescape View File

@ -0,0 +1,14 @@
#define true 1
#define false 0
#define boolean char
#define byte char
struct String{
int length;
char*str;
};
struct String add(struct String numb1, struct String numb2);
struct String mult(struct String numb1, struct String numb2);
void printLongDoubleArr(int a,int b,long doubleArr[a][b]);
void printIntDoubleArr(int a,int b,int doubleArr[a][b]);
struct String createBigNumber(char*numb);
#define BigNumber(X) createBigNumber(#X)

BIN
current
View File

Binary file not shown.

89
src/main.c
Unescape View File

@ -11,43 +11,68 @@
https://projecteuler.net/problem=24 https://projecteuler.net/problem=24
*/ */
void generate(int*a,int count,boolean useNextHighest) { void carryover(int*arr,int digit) {
arr[digit]=0;
if (arr[digit-1]==9) {
carryover(arr,digit-1);
} else {
arr[digit-1]++;
}
}
void incrementDigit(int*arr) {
int val = arr[9];
if (arr[9]==9) {
carryover(arr,9);
} else {
arr[9]++;
}
}
boolean allUniqueDigits(int*arr) {
boolean digits[10] = {};
for (int i=0;i<10;i++) { for (int i=0;i<10;i++) {
int*newArr=malloc(sizeof(int)*(count+1)); if (!digits[arr[i]]) {
newArr[i]=i; digits[arr[i]]=true;
generate(newArr,count+1,true); } else {
generate(newArr,count+1,false); return false;
}
}
return true;
}
int factorial(int numb) {
int final=1;
for (int i=numb;i>=1;i--) {
final*=i;
} }
return final;
} }
int main(int argc,char**argv) { int main(int argc,char**argv) {
//X * (2^(X-2))
//0 //For permutations, we know that there are a total of N! permutations.
//01 // Which means each individual set starts at N!/N. So we can skip ahead some permutations.
//02 // For 10 numbers, we get 362,880 values per permutation set. So 1000000/362880 = 2. So we'll start at permutation two.
//03 int setPermutationCount=factorial(10)/10;
//04 int permutationCount=(1000000/setPermutationCount)*setPermutationCount;
//05 int digits[10]={2,0,1,3,4,5,6,7,8,9};
//06 while ((digits[0]!=9||digits[1]!=8||digits[2]!=7||digits[3]!=6||digits[4]!=5||digits[5]!=4||digits[6]!=3||digits[7]!=2||digits[8]!=1||digits[9]!=0)&&permutationCount!=999999) {
//07 incrementDigit(digits);
//08 if (allUniqueDigits(digits)) {
//09 permutationCount++;
//10 printf("%d:",permutationCount);
//123 for (int i=0;i<10;i++) {
//124 printf(" %d ",digits[i]);
//20 }
//21 printf("\n");
//3 }
//4 }
//5
//6 printf("\n\nThe one millionth lexicographic permutation is: \n\t");
//7 for (int i=0;i<10;i++) {
//8 printf("%d",digits[i]);
//9 }
boolean useNextHighest=true; //If this is true, use the next consecutive digit, otherwise skip one.
int*numbs=malloc(sizeof(int)*0);
generate(numbs,count,true);
return 0; return 0;

Write Preview
Loading…
Cancel
Save