You are given two streams 's_a' and 's_b' of digits. Each stream represents an integer 'a' and 'b' from its less significant digit to the most significant digit.
For example, integer 2048 is represented in the stream as 8, 4, 0, 2.
Write a function that subtract two integers 'a - b' and returns the result as a string. You are not allowed to buffer entire 'a' or 'b' into a single string, i.e. you may access only a single digit per stream at time (imagine that 'a' and 'b' are stored in huge files). You may assume that 'a>=b'.
#include <stdio.h>
/* Subtracts two single digits, prints the reminder and returns 1(carry) if a<b */
int subtract(char c_a, char c_b)
{
/* Convert the char to interger */
int i_a = c_a - '0';
int i_b = c_b - '0';
int ret = 0;
/* If a<b, increase 'a' by 10 and return 1(carry) to subtract it from 'a' of the next set */
if (i_a < i_b) {
i_a += 10;
ret = 1;
}
printf ("%d", i_a - i_b);
return ret;
}
int main(int agrc, char **argv)
{
/* Get the two operand streams from input arguments */
char *s_a = argv[1];
char *s_b = argv[2];
int carry_one = 0;
/* Pass one char at a time from each input arguments to function subtract */
while(*s_b != '\0'){
/* Subtract carry_one from first operand before sending it to function subtract */
carry_one = subtract(*s_a - carry_one, *s_b);
s_a++;
s_b++;
}
/* Print the remining digits from the first operand */
while(*s_a != '\0'){
printf("%c", *s_a - carry_one);
s_a++;
carry_one = 0;
}
printf("\n");
return 0;
}
ord(c): Given a string of length one, return an integer representing the Unicode code point of the character when the argument is a unicode object, or the value of the byte when the argument is an 8-bit string.
hex(n): Convert an integer number to a hexadecimal string
We do not need first to characters in the hex output.
zfill(witdh): Return the numeric string left filled with zeros in a string of length width.
Substitution Operator Modifiers
Here is the list of all modifiers used with substitution operator
Modifier Description
i Makes the match case insensitive
m Specifies that if the string has newline or carriage
return characters, the ^ and $ operators will now
match against a newline boundary, instead of a
string boundary
o Evaluates the expression only once
s Allows use of . to match a newline character
x Allows you to use white space in the expression
for clarity
g Replaces all occurrences of the found expression
with the replacement text
e Evaluates the replacement as if it were a Perl statement,
and uses its return value as the replacement text
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define ERRNUM -1
#define SUCCESS 0
#define TRUE 1
#define FALSE 0
#define TOTAL_ALPHA 26
/* Function : permutations
* Args : str [IN]
* index [IN]
* result [IN/OUT]
* Description: Function will print all the permutations and combinations of a given string
* without repeated patterns. PnC(ABC) = { A+PnC(BC), B+PnC(CA), C+PnC(AB) }
* Note : This "without repeated patterns" will not work for non-alpha characters [TBD].
*/
int permutations (char *str, int index, char *result)
{
char *temp = NULL; // To store the given string for processing
int len = strlen (str); // Length of the given string
int count = 0; // Counter variable used in the loop
int j = 0; // Temporary variable
char found[52] = {0}; // To check the variable to check the duplicate characters to avoid duplicate patterns
/* Allocate memory for the temp variable to store the given string for processing.
* So that the given string will not change.
*/
temp = (char *) calloc (len+1, sizeof (char));
if (NULL == temp)
{
fprintf (stderr, "Memory allocation failed.\n");
return ERRNUM;
}
/* Copy the given string into the temporary variable */
strcpy (temp, str);
/* Traverse through the string and find the permutations and combinations of the substring
* PnC(ABC) = { A+PnC(BC), B+PnC(CA), C+PnC(AB) }
*/
for (count=0; count < len; count++)
{
char ch = 0;
*(result + index) = *temp;
if (1 == len)
{
/* We can store in an array of string or a stack */
printf ("%s\n", result);
}
else
{
if (isupper (*temp))
{
if (FALSE == found [TOTAL_ALPHA + (*temp) - 'A'])
{
found [TOTAL_ALPHA + (*temp) - 'A'] = TRUE;
}
else
{
/* Its a duplicate character */
goto NEXT;
}
}
else if (islower (*temp))
{
if (FALSE == found [(*temp) - 'a'])
{
found [(*temp) - 'a'] = TRUE;
}
else
{
/* Its a duplicate character */
goto NEXT;
}
}
/* We can store in an array of string or a stack */
for (j=0; j<=index; j++)
{
printf ("%c", *(result+j));
}
printf ("\n");
/* Find the permutations and combinations for the substring too */
if (ERRNUM == permutations (temp+1, index+1, result))
{
return ERRNUM;
}
NEXT:
ch = *temp;
memcpy (temp, temp+1, len-1);
temp[len-1] = ch;
}
}
/* Free the allocated memory for the temporary variable */
free (temp);
return SUCCESS;
}
int main (int argc, char *argv[])
{
char *result = NULL; // Variable to store the result for printing
int retVal = SUCCESS; // Variable to stroe the return value
// No code to check/validate the input [TBD].
if (NULL == result)
{
result = (char *) calloc (strlen (argv[1])+1, sizeof (char));
if (NULL == result)
{
fprintf (stderr, "Memory allocation failed.\n");
return ERRNUM;
}
}
retVal = permutations (argv[1], 0, result);
free (result);
return retVal;
}
The results:
prompt$ ./permutationsNconbination ABC
A
AB
ABC
AC
ACB
B
BC
BCA
BA
BAC
C
CA
CAB
CB
CBA
prompt$ ./permutationsNconbination AAB
A
AA
AAB
AB
ABA
B
BA
BAA
prompt$ ./permutationsNconbination AAA
A
AA
AAA
prompt$
