I'm trying to solve some problems. but there is something wrong with my code.
The problem is : Given a number n, output n*n in the following format.
Input:
n=3
Output:
7 8 1
6 9 2
5 4 3
Here is my code: (I know there are some bugs in it, but I can't fix it. If you have better ideas, help me.)
Thank in advance.
#include<stdio.h>
#include<stdlib.h>
void oput(int **matrix,int n);
int main()
{ int x=0,y=0,n,k=1;
scanf("%d",&n);
int **matrix = malloc(sizeof(int)*n*n);
if(matrix==NULL)
{
perror("can't allocate");
return 1;
}
//Input values to x*y matrix
while(n>=1)
{
for(x=0,y=n-1;x<n;x++)
{
matrix[x][y]=k++;
}
for(x=n-1,y=n-1;y>=0;y--)
{
matrix[x][y]=k++;
}
for(x=n-1,y=0;x>=0;x--)
{
matrix[x][y]=k++;
}
n--;
}
oput(matrix,n);
free(matrix);
return 0;
}
//output values by row.
void oput(int **matrix,int n)
{
int i=0,j=0;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("%d ",matrix[i][j]);
}
printf("\n");
}
}
Error arises at running time.
Just for fun I worked on a solution for this problem.
I'm not allowed to write comments under the question, yet, so I assumed that starting the "spiral numbering" from the upper right corner of the matrix was a requirement of the problem.
My solution consists in adding numbers all over the perimeter, using four different loops. And then starting again adding an indentation level.
#include <stdio.h>
#include <string.h>
void printMatrix( int *nMatrix, int n, char *title )
{
int i, j;
if( title )
printf( "%s\n", title );
for( i=0; i<n; i++ )
{
for( j=0; j<n; j++ )
{
printf( "%d\t", *(nMatrix+n*i+j) );
}
printf( "\n" );
}
}
void main( int argc, char *argv[] )
{
if( argc == 2 )
{
int n = atoi ( argv[1] );
int i, j;
printf( "Input value: %d\n", n );
if( n > 0 && n <= 10 )
{
int spiral[n][n];
int indentNr, x, y, lastNr=0;
memset( spiral, 0, n*n*sizeof( int ));
/* As indentNr is incremented, inner frames are filled */
for( indentNr=0; n-2*indentNr>0; indentNr++ )
{
/* Go South */
for( x=indentNr, y=n-1-indentNr; x<n-indentNr; x++ )
{
spiral[x][y] = ++lastNr;
}
/* Go West (Village People, 1979) */
for( y=n-2-indentNr, x=n-1-indentNr; y>=indentNr; y-- )
{
spiral[x][y] = ++lastNr;
}
/* Go North */
for( x=n-2-indentNr, y=indentNr; x>=indentNr; x-- )
{
spiral[x][y] = ++lastNr;
}
/* Go East */
for( y=1+indentNr, x=indentNr; y<n-1-indentNr; y++ )
{
spiral[x][y] = ++lastNr;
}
}
/* Print results */
printMatrix( &(spiral[0][0]), n, "Final spiral:" );
}
else
{
printf( "ERROR: 'n' too big!\n" );
}
}
else
{
printf( "USAGE: spiral n\n" );
}
}
Please note that:
Input of 'n' is inserted with main argument (no scanf)
I limited 'n' to 10
This solution is iterative. I did not analyse recursive solutions
There is probably a more elegant solution for skipping all 4 loops for inner frames with n=1 and n=2. I did not spent much time in figuring it out
I tested both odd and even scenarios and both seem to work fine. I tested up to n=10. I don't expect troubles for bigger numbers (except for presentation issues in case of big numbers), but feel free to report me any bug.
Related
I have a problem question and a snippet code below. The snippet is filled already because I found out the solution but I do not understand why it is like that. Could you help me explain how the codes work?
Problem: Ten tiles each have strings of in between 1 and 4 letters on them (hardcoded in the code below). The goal of this problem is to complete the code below so it counts the number of different orders in which all of the tiles can be placed such that the string they form creates a palindrome (a word that reads the same forwards and backwards). All of main, as well as the function eval which determines if a particular ordering of the tiles forms a palindrome. You may call this function in the function go. Complete the recursive function (named go) to complete the solution.
Snippet code:
#include <stdio.h>
#include <string.h>
#define N 10
#define MAXLEN 5
int go(int perm[], int used[], int k, char tiles[N][MAXLEN]);
int eval(int perm[], char tiles[N][MAXLEN]);
char MYTILES[N][MAXLEN] = {
"at", "ta", "g", "cc", "ccac", "ca", "cc", "gag", "cga", "gc"
};
int
main(void)
{
int perm[N];
int used[N];
for (int i = 0; i < N; i++)
used[i] = 0;
int res = go(perm, used, 0, MYTILES);
printf("Number of tile orderings that create palindromes is %d\n", res);
return 0;
}
int
go(int perm[], int used[], int k, char tiles[N][MAXLEN])
{
if (k == N)
return eval(perm, tiles);
int res = 0;
for (int i = 0; i < N; i++) {
if (used[i])
continue;
used[i] = 1;
perm[k] = i;
res += go(perm, used, k + 1, tiles);
used[i] = 0;
}
return res;
}
int
eval(int perm[], char tiles[N][MAXLEN])
{
char tmp[N * MAXLEN];
int idx = 0;
for (int i = 0; i < N; i++) {
int len = strlen(tiles[perm[i]]);
for (int j = 0; j < len; j++)
tmp[idx++] = tiles[perm[i]][j];
}
tmp[idx] = '\0';
for (int i = 0; i < idx / 2; i++)
if (tmp[i] != tmp[idx - 1 - i])
return 0;
return 1;
}
Thank you. I appreciate all help!!
To understand this code, add the following line to the start of eval():
for( int j = 0; j < N; j++ ) printf( "%d ", perm[j] ); putchar('\n');
The for() loop in go() causes a recursion that is 10 levels deep, ultimately generating 10! (~3.6 million) permutations of the 10 indices from 0 to 9. In sequence, each of those permutations is used to concatenate the 'tokens' (the short ACTG variations) into a single string that is then tested for being palindromic by `eval()'
This is called a "brute force" search through the possibility space.
Below I've revised the code to be slightly more compact, adding two "printf debugging" lines (marked "/**/") that report what the program is doing. You'll need some patience if you wish to watch millions of permutations of 0 to 9 scroll by, or simply comment out that line and recompile. I also shuffled things around and made the two interesting arrays global instead of "whacking the stack" by passing them up/down the recursion. Less code is better. This program is "single purpose". The clarity gained justifies using global variables in this instance, imho.
More interesting is the additional puts() line that reports the palindromic sequences.
#include <stdio.h>
#include <string.h>
#define N 10
#define MAXLEN 5
char MYTILES[N][MAXLEN] = { "AT","TA","G","CC","CCAC","CA","CC","GAG","CGA","GC" };
int perm[N], used[N] = { 0 };
int go( int k ) {
if (k == N) {
// At extent of recursion here.
/**/ for( int j = 0; j < k; j++ ) printf( "%d ", perm[j] ); putchar('\n');
// Make a string in this sequence
char tmp[N*MAXLEN] = {0};
for( int i = 0; i < N; i++ )
strcat( tmp, MYTILES[ perm[ i ] ] );
// Test string for being palidromic
for( int l = 0, r = strlen( tmp ) - 1; l <= r; l++, r-- )
if( tmp[l] != tmp[r] )
return 0; // Not palidrome
/**/ puts( tmp );
return 1; // Is palidrome
}
// recursively generate permutations here
int res = 0;
for( int i = 0; i < N; i++ )
if( !used[i] ) {
used[i] = 1;
perm[k] = i;
res += go( k+1 );
used[i] = 0;
}
return res;
}
int main( void ) {
printf( "Palindromic tile orderings: %d\n", go( 0 ) );
return 0;
}
An immediate 'speed-up' would be to test that the first letter of the 0th string to be permuted matches the last letter of the 9th string... Don't bother concatenating if a palindrome is impossible from the get-go. Other optimisations are left as an exercise for the reader...
BTW: It's okay to make a copy of code and add your own print statements so that the program reports what it is doing when... Or, you could single-step through a debugger...
UPDATE
Having added a preliminary generation of a 10x10 matrix to 'gate' the workload of generating strings to be checked as palindromic, with the 10 OP supplied strings, it turns out that 72% of those operations were doomed to fail from the start. Of the 3.6 million "brute force" attempts, a quick reference to this pre-generated matrix prevented about 2.6 million of them.
It's worthwhile trying to make code efficient.
UPDATE #2:
Bothered that there was still a lot of 'fat' in the execution after trying to improve on the "brute force" in a simple way, I've redone some of the code.
Using a few extra global variables (the state of processing), the following now does some "preparation" in main(), then enters the recursion. In this version, once the string being assembled from fragments is over half complete (in length), it is checked from the "middle out" if it qualifies as being palindromic. If so, each appended fragment causes a re-test. If the string would never become a palindrome, the recursion 'backs-up' and tries another 'flavour' of permutation. This trims the possibility space immensely (and really speeds up the execution.)
char *Tiles[] = { "AT","TA","G","CC","CCAC","CA","CC","GAG","CGA","GC" };
const int nTiles = sizeof Tiles/sizeof Tiles[0];
int used[ nTiles ];
char buildBuf[ 1024 ], *cntrL, *cntrR; // A big buffer and 2 pointers.
int fullLen;
int cntTested, goCalls; // some counters to report iterations
uint32_t factorial( uint32_t n ) { // calc n! (max 12! to fit uint32_t)
uint32_t f = 1;
while( n ) f *= n--;
return f;
}
int hope() { // center outward testing for palindromic characteristics
int i;
for( i = 0; cntrL[ 0 - i ] == cntrR[ 0 + i ]; i++ ) ; // looping
return cntrR[ 0 + i ] == '\0';
}
int go( int k ) {
goCalls++;
if( k == nTiles ) { // at full extent of recursion here
// test string being palindromic (from ends toward middle for fun)
cntTested++;
for( int l = 0, r = fullLen - 1; l <= r; l++, r-- )
if( buildBuf[l] != buildBuf[r] )
return 0; // Not palindrome
/**/ puts( buildBuf );
return 1; // Is palindrome
}
// recursively generate permutations here
// instead of building from sequence of indices
// this builds the (global) sequence string right here
int res = 0;
char *at = buildBuf + strlen( buildBuf );
for( int i = 0; i < nTiles; i++ )
if( !used[i] ) {
strcpy( at, Tiles[ i ] );
// keep recursing until > half assembled and hope persists
if( at < cntrL || hope() ) {
used[i] = 1;
res += go( k+1 ); // go 'deeper' in the recursion
used[i] = 0;
}
}
return res;
}
int main( void ) {
for( int i = 0; i < nTiles; i++ )
fullLen += strlen( Tiles[i] );
if( fullLen % 2 == 0 ) // even count
cntrR = (cntrL = buildBuf + fullLen/2 - 1) + 1; // 24 ==> 0-11 & 12->23
else
cntrR = cntrL = buildBuf + fullLen/2; // 25 ==> 0-12 & 12->24
printf( "Palindromic tile orderings: %d\n", go( 0 ) );
printf( "Potential: %d\n", factorial( nTiles ) );
printf( "Calls to go(): %d\n", goCalls );
printf( "Actual: %d\n", cntTested );
return 0;
}
ATCCACGAGCCGCCGAGCACCTA
ATCCACGAGCCGCCGAGCACCTA
ATCCACGCCGAGAGCCGCACCTA
ATCCACGCCGAGAGCCGCACCTA
ATCACCGAGCCGCCGAGCCACTA
ATCACCGCCGAGAGCCGCCACTA
ATCACCGAGCCGCCGAGCCACTA
ATCACCGCCGAGAGCCGCCACTA
TACCACGAGCCGCCGAGCACCAT
TACCACGAGCCGCCGAGCACCAT
TACCACGCCGAGAGCCGCACCAT
TACCACGCCGAGAGCCGCACCAT
TACACCGAGCCGCCGAGCCACAT
TACACCGCCGAGAGCCGCCACAT
TACACCGAGCCGCCGAGCCACAT
TACACCGCCGAGAGCCGCCACAT
CCACATGAGCCGCCGAGTACACC
CCACATGAGCCGCCGAGTACACC
CCACATGCCGAGAGCCGTACACC
CCACATGCCGAGAGCCGTACACC
CCACTAGAGCCGCCGAGATCACC
CCACTAGAGCCGCCGAGATCACC
CCACTAGCCGAGAGCCGATCACC
CCACTAGCCGAGAGCCGATCACC
CACCATGAGCCGCCGAGTACCAC
CACCATGCCGAGAGCCGTACCAC
CACCTAGAGCCGCCGAGATCCAC
CACCTAGCCGAGAGCCGATCCAC
CACCATGAGCCGCCGAGTACCAC
CACCATGCCGAGAGCCGTACCAC
CACCTAGAGCCGCCGAGATCCAC
CACCTAGCCGAGAGCCGATCCAC
Palindromic tile orderings: 32
Potential: 3628800
Calls to go(): 96712
Actual: 32
UPDATE #3 (having fun)
When there's too much code, and an inefficient algorithm, it's easy to get lost and struggle to work out what is happening.
Below produces exactly the same results as above, but shaves a few more operations from the execution. In short, go() is called recursively until at least 1/2 of the candidate string has been built-up. At that point, hope() is asked to evaluate the string "from the middle, out." As long as the conditions of being palindromic (from the centre, outward) are being met, that evaluation is repeated as the string grows (via recursion) toward its fullest extent. It is the "bailing-out early" that makes this version far more efficient than the OP version.
One further 'refinement' is that the bottom of the recursion is found without an extra call to \0. Once one has the concepts of recursion and permutation, this should all be straight forward...
char *Tiles[] = { "AT", "TA", "G", "CC", "CCAC", "CA", "CC", "GAG", "CGA", "GC" };
const int nTiles = sizeof Tiles/sizeof Tiles[0];
int used[ nTiles ];
char out[ 1024 ], *cntrL, *cntrR;
int hope() { // center outward testing for palidromic characteristics
char *pL = cntrL, *pR = cntrR;
while( *pL == *pR ) pL--, pR++;
return *pR == '\0';
}
int go( int k ) {
int res = 0;
char *at = out + strlen( out );
for( size_t i = 0; i < nTiles; i++ )
if( !used[i] ) {
strcpy( at, Tiles[ i ] );
if( at >= cntrL && !hope() ) // abandon this string?
continue;
if( k+1 == nTiles ) { // At extent of recursion here.
puts( out );
return 1;
}
used[i] = 1, res += go( k+1 ), used[i] = 0;
}
return res;
}
int main( void ) {
int need = 0;
for( size_t i = 0; i < nTiles; i++ )
need += strlen( Tiles[ i ] );
cntrL = cntrR = out + need/2; // odd eg: 25 ==> 0-12 & 12->24
cntrL -= (need % 2 == 0 ); // but, if even eg: 24 ==> 0-11 & 12->23
printf( "Palindromic tile orderings: %d\n", go( 0 ) );
return 0;
}
I'm learning C, and I wrote a program that reads a list of numbers and provides the sum, max, min and mean of the list. The list ends when a negative number is typed.
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i, number, sum, divider, min, max;
double mean;
int addend[1000];
char s[80];
for (i=0; i>=0; i++) {
fgets (s, sizeof(s), stdin);
number = atoi(s);
addend[i]=number;
if (addend[i]>=0) {
continue;
}
else break;
}
divider=i;
i=i-1;
sum=addend[i];
while (i>=1) {
sum=sum+addend[i-1];
i=i-1;
}
printf("[SUM]\n%i\n", sum);
if (addend[0]<0) {
printf("[MIN]\n0\n\n[MAX]\n0\n\n[MEAN]\n0\n");
}
else {
mean=sum/divider;
i=divider-1;
min=addend[i];
while (i>=0) {
if (addend[i-1]<min) {
min=addend[i-1];
}
i=i-1;
}
max=addend[i];
while (i>=0) {
if (addend[i-1]>max) {
max=addend[i-1];
}
i=i-1;
}
printf("[MIN]\n%i\n\n[MAX]\n%i\n\n[MEAN]\n%f\n", min, max, mean);
}
return 0;
}
Everything works fine, except the max (if i type "3, 6, 8, 9, -1" the max is 1075314688). I already found a solution (if I write max=addend[divider-1] on line 42 it works fine), but I'm trying to understand why the code I originally wrote doesn't work. I tried searching for the answer online but I didn't find anything.
You don't reset i when you're recalculating the max.
You need to insert i=divider-1; before max=addend[i]; like you did for the minimum:
i=divider-1;
min=addend[i];
while (i>=0) {
if (addend[i-1]<min) {
min=addend[i-1];
}
i=i-1;
}
i=divider-1; //Unless you do this i==-1 at this point!
max=addend[i];
while (i>=0) {
if (addend[i-1]>max) {
max=addend[i-1];
}
i=i-1;
}
PS: You should learn about for(;;) loops.
This code is asking to be converted in to standard loops.
I'm also not sure why you have (i>=0) and then addend[i-1] when i==0 doesn't that access addend[-1]?
In general this code snippet
i=i-1;
sum=addend[i];
can invoke undefined behavior if the first entered number will be negative. In this case i will be equal to 0 and the expression i - 1 will be equal to -1. That means that the expression addend[i] accesses memory beyond the array.
This while loop invokes undefined behavior
i=divider-1;
min=addend[i];
while (i>=0) {
if (addend[i-1]<min) {
min=addend[i-1];
}
i=i-1;
}
because when i is equal to 0 the expression addend[i-1] accesses memory beyond the array addend.
And moreover after above loop is equal to -1 so this statement
max=addend[i];
again invokes undefined behavior and the following loop
while (i>=0) {
if (addend[i-1]>max) {
max=addend[i-1];
}
i=i-1;
}
will not be executed.
Also pay attention to that in this statement in the right-side of the assignment
mean=sum/divider;
there is used the integer arithmetic.
The program can look the following way.
#include <stdio.h>
#include <stdlib.h>
int main( void )
{
enum { N = 1000 };
int addend[N];
char s[80];
size_t n = 0;
while ( n < N && fgets (s, sizeof( s ), stdin ) != NULL )
{
int number = atoi( s );
if ( !( number < 0 ) )
{
addend[n++] = number;
}
else
{
break;
}
}
if ( n == 0 )
{
printf("[MIN]\n0\n\n[MAX]\n0\n\n[MEAN]\n0\n");
}
else
{
long long int sum = 0;
for ( size_t i = 0; i < n; i++ )
{
sum += addend[i];
}
printf( "[SUM]\n%lld\n", sum );
int min = addend[0];
int max = addend[0];
for ( size_t i = 1; i < n; i++ )
{
if ( max < addend[i] )
{
max = addend[i];
}
else if ( addend[i] < min )
{
min = addend[i];
}
}
double mean = ( double )sum / n;
printf( "[MIN]\n%i\n\n[MAX]\n%i\n\n[MEAN]\n%f\n", min, max, mean);
}
}
Recently I was studying about quicksort,
I wrote 2 programs: One works successfully, while the other doesn't.
I tried to find why the other one is not working.(I know the reason but I want to know the reason under the reason)
The only difference between 2 programs is a line in quicksort5 function,
which is below:
swap( &list[ ( (backwards-forwards) /2 ) ], &list[last] );
They both includes stdio.h and also have 3 functions which are called main, quicksort5, swap.
The upper lines of the program is below:
#include <stdio.h>
int quicksort5(int *, int, int);
int swap(int *, int *);
1) The main function is below:
int main()
{
int arrayofintegers[4096];
int n=0, quantity=0;
printf("Please enter how many integer numbers you want to get sorted: ");
scanf("%d",&quantity);
if (quantity <= 0)
return -1;
printf("\nPlease give at max 10 digits per number.\n\n");
while ( n<quantity ) //import the numbers
{
printf("the %5d. number = ",n+1);
scanf("%d",&arrayofintegers[n]);
n++;
}
printf("\n");
quicksort5(arrayofintegers, 0, quantity-1);
n=0;
while ( n<quantity ) //The numbers will be displayed.
{
printf("the new %5d. number =%11d\n", n+1, arrayofintegers[n]);
n++;
}
return 0;
}
2) The quicksort5 function is below:
int quicksort5(int *list, int forwards, int backwards)
{
if ( forwards >= backwards )
return 0;
int const first = forwards;
int const last = backwards;
/* //If I make the line bellow active the function doesn't sort successfully. But I want to know the main reason in this.
swap( &list[ ( (backwards-forwards) /2 ) ], &list[last] ); */
int const pivot = list[last];
int isforwardswaiting = 0;
int isbackwardswaiting = 0;
backwards--; // the pivot won't change
while (forwards<backwards)
{
isforwardswaiting = (list[forwards] >= pivot);
isbackwardswaiting = (list[backwards] < pivot);
if(isforwardswaiting && isbackwardswaiting)
{
swap(&list[forwards],&list[backwards]);
forwards++;
backwards--;
}
else
{
if ( !(isforwardswaiting))
forwards++;
if ( !(isbackwardswaiting))
backwards--;
}
}
if (list[forwards] < pivot)
forwards++;
swap(&list[forwards],&list[last]); //placing the pivot
/* list[first], list[first+1] ... list[forwards-2], list[forwards-1] ==> the numbers smaller than the pivot
list[forwards] ==> the number which is the pivot
list[forwards+1], list[forwards+2] ... list[last-1], list[last] ==> the numbers greater than the pivot */
quicksort5(list, first, forwards-1);
quicksort5(list, forwards+1, last);
}
3) The swap function is below:
int swap(int *a, int *b)
{
int c=*a;
*a=*b;
*b=c;
return 0;
}
Thanks in advance for your answers.
You just need to modify the following line in your function quicksort5 :
swap( &list[ ( (backwards-forwards) /2 ) ], &list[last] );
to this:
swap( &list[ (forwards + (backwards-forwards) /2 ) ], &list[last] );
To understand why the first statement causes problem, consider the case when backwards = 6 and forwards = 4.
So, (backwards-forwards) /2 evaluates to 1, and the swap function swaps the element at index 6 with the one at index 1, which is not desired.
Hope it helps!
I don't know what is the matter.. it works great when I run on my pc but when I submit in uva OJ it says time limit exceeded please help
Here is my solution:
#include <stdio.h>
int main()
{
long int i,j,c,t,k,u,r;
scanf("%d %d",&i,&j);
printf("%d %d",i,j);
r = 0;
if(i>j){
t = i;
i = j;
j = t;
}
for(k = i; k<=j;k++){
c = 1;
u = k;
while(u>1){
if(u%2 == 0)
u = u/2;
else
u = 3*u+1;
c++;
if(c>=r)
r = c;
}
}
printf (" %d",r);
return 0;
}
The following code, on my ubuntu Linux 14.04 takes about 1 second to run, when invoked via:
./untitled > outfile.txt
so perhaps this could be useful.
Note: this will have to be modified significantly for the euler problem
Note: the problem says "UNDER" 1 million, but this code starts at 1 million rather than starting at 999999
// Longest Collatz sequence
// Problem 14
/*
* criteria
* The following iterative sequence is defined for the set of positive integers:
* n → n/2 (n is even)
* n → 3n + 1 (n is odd)
*
* example:
* Using the rule above and starting with 13, we generate the following sequence:
* 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
* It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms.
* Although it has not been proved yet (Collatz Problem),
* it is thought that all starting numbers finish at 1.
*
* the question:
* Which starting number, under one million, produces the longest chain?
*
* Note:
* Once the chain starts the terms are allowed to go above one million.
*/
#include <stdio.h>
// prototypes
void fastWrite( size_t a );
int main( void )
{
#define MAX_START_VALUE (1000000)
size_t LongestChain = 0;
size_t LongestStartValue = 0;
for( size_t i=MAX_START_VALUE; i; i--)
{
size_t chainLength = 0;
size_t result = i;
// for debug
char buffer[] = "current start value:";
for( size_t j=0; buffer[j]; j++) putchar_unlocked( buffer[j] );
putchar_unlocked( ' ');
fastWrite( i );
// end debug
while( result != 1 )
{
chainLength++;
if( result&1 )
{ // then odd
result = 3*result +1;
}
else
{ // else even
result >>= 1;
}
// for debug
//./fastWrite( result );
// end debug
}
chainLength++;
// for debug
char buffer2[] = "chain length: ";
for( size_t k=0; buffer2[k]; k++) putchar_unlocked( buffer2[k] );
fastWrite( chainLength );
putchar_unlocked( '\n' );
// end debug
if ( chainLength > LongestChain )
{
LongestChain = chainLength;
LongestStartValue = i;
}
}
fastWrite( LongestStartValue );
putchar_unlocked('\n');
//putchar_unlocked('\n');
} // end function: main
inline void fastWrite(size_t a)
{
char snum[20];
//printf( "%s, %lu\n", __func__, a );
int i=0;
do
{
// 48 is numeric character 0
snum[i++] = (char)((a%10)+(size_t)48);
a=a/10;
}while(a>0);
i=i-1; // correction for overincrement from prior 'while' loop
while(i>=0)
{
putchar_unlocked(snum[i--]);
}
putchar_unlocked('\n');
} // end function: fastWrite
Just to be helpful with the time taken:
the following are good ways to speed up the I/O
#include <stdio.h>
void fastRead( size_t *a );
void fastWrite( size_t a );
inline void fastRead(size_t *a)
{
int c=0;
// note: 32 is space character
while (c<33) c=getchar_unlocked();
// initialize result value
*a=0;
// punctuation parens, etc are show stoppers
while (c>47 && c<58)
{
*a = (*a)*10 + (size_t)(c-48);
c=getchar_unlocked();
}
//printf( "%s, value: %lu\n", __func__, *a );
} // end function: fastRead
inline void fastWrite(size_t a)
{
char snum[20];
//printf( "%s, %lu\n", __func__, a );
int i=0;
do
{
// 48 is numeric character 0
snum[i++] = (char)((a%10)+(size_t)48);
a=a/10;
}while(a>0);
i=i-1; // correction for overincrement from prior 'while' loop
while(i>=0)
{
putchar_unlocked(snum[i--]);
}
putchar_unlocked('\n');
} // end function: fastWrite
and output characters via:
putchar_unlocked( char );
and always have a final, at end of each test case, the following line:
putchar_unlocked( '\n' );
to input a string of characters, call the following in a loop until a space or newline is encountered
char = getchar_unlocked()
and a final hint: most such problems are easily solved using size_t numeric values, which allows values to 4gig or more. (same as a unsigned long int)
For the current problem. as soon as a chain is calculated, save the chain, perhaps in an array, so you do not have to calculate it again.
Your could pre-calculate the first 'x' chains, say the first 10 for instance, to help with shortening the execution time.
Lets say if the input is 4 then the output should be all possible 4 letter words with letters a to f. All the way from aaaa to ffff. How would I do this through the use of recursion?
My apologies for not including my attempt at the problem in my initial question. And some for you are wondering why I am using recursion instead of using a simpler method (such as a for loop for example) and the reason for this is that my prof wants us to use a for loop to solve this problem.
Here is my attempt at doing this:
void allPossiblilities(int n)
{
char*result;
if(Done(result))/*since the last possibility will be all f I am using that as my base case*/
{
printf("%s",result);
return;
}
/*This is where the recursive part should go but I am totally lost as to what it should be*/
}
bool Done(result)/*This function just returns true if all the array's index are f*/
{
int i;
bool a=true;
for(i=0;i<=n-1;i++)
if(result[i]!='f')
a=false;
}
return a;
}
I will give you a hint, to make you think:
How many possibilities are for 4 digits and 10 possible numbers (0-9) base^digits = 10^4 = 10000 possible outputs 0000-9999, in your case they will base = 6 (A-F) and exp = 4 (4 positions) 6^4 = 1296 combinations.
How are recursive functions made?
They have 2 steps:
Basic Step: it's the criteria or the condition when the function doesn't call itself ( the final condition).
Recursive Step: It's the criteria or the condition when the function calls itself, and the result of it should be nearer to the Basic Step.
Example the famous factorial function, the basic step is the return of 1, and the recursive step is the second one.
PD: I am trying to make you analyze the problem and get the solution by yourself, and giving you some tools.
The code:
#include <stdio.h>
#include <stdlib.h>
void recurs( int * s );
void print( int * s );
int main( void )
{
int a[] = { 0, 0, 0, 0 };
print( a );
recurs( a );
}
void recurs( int * s )
{
int i;
/*Basic Case*/
if( s[ 3 ] == 5 && s[ 2 ] == 5 && s[ 1 ] == 5 && s[ 0 ] == 5 ){
print( s );
printf( "\nAccomplisshed!\n" );
}
else{
s[ 0 ] += 1;
for( i = 0; i < 3; i++ ){
if( s[ i ] == 6 ){
s[ i ] = 0;
s[ i + 1 ] += 1;
}
}
print( s );
recurs( s );
}
}
/* This only prints. */
void print( int * s )
{
int i;
printf( " " );
for( i = 3; i >= 0; i-- ){
printf( "%c", ( s[ i ] + 65 ) );
}
}
Part of the output:
int inc(char *c,char begin, char end){
if(c[0]==0) return 0;
if(c[0] == end){ // This make the algorithm to stop at char 'f'
c[0]=begin; // but you can put any other char
return inc(c+sizeof(char));
}
c[0]++;
return 1;
}
int all(int a, int n,char begin, char end){
int i,j;
char *c = malloc((n+1)*sizeof(char));
for(i=a;i<=n;i++){
for(j=0;j<i;j++) c[j]=begin;
c[i]=0;
do {
printf("%s\n",c);
} while(inc(c,begin,end));
}
free(c);
}
int main(void){
all(4,4,'a','f'); // Generates from 4 letters words starting in aaaa to ffff
}
If you call all(1,4,'a','f') it will generate a,b,c,d...ffff
If you call all(4,4,'a','z') it will generate from aaaa to zzzz
Just for the hell of using hex notation to generate a-f characters:
#include <stdio.h>
int v(unsigned char* i, unsigned short n) {
return !n || (*i>=0xa0 && (*i&0xf)>=10 && v(i+1,n-1));
}
void f(unsigned short i) {
if(i) f(i-1);
if(v((char*)&i,2)) printf("%x\n",i);
}
int main(){ f((1<<16)-1);}