This is a rather easy geometry / computational geometry problem. Given the radius of a Circumscribed circle and count of sides of a polygon the task is to find the area of the polygon. A Circumscribed circle is a circle that passes through all vertices of a plane figure and contains the entire figure in its interior.

The formula below can be written into a single formula by combining all the formulas. More information and the combined formula can be found here.

I have tried to explain the concept below using figures. They are not drawn to scale. The small circles represent intersection point between polygon vertices and the circumscribed circle.

Example:

It is an example with radius, r = 2 and sides, n = 8.

Important:Be sure to add or print a new line after each output unless otherwise specified. The outputs should match exactly because sometimes even a space character causes the answer to be marked as wrong answer. Please compile with c++ compiler as some of my codes are in c and some in c++.

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 10432 - Polygon Inside A Circle
* Technique: circumcircle Or, Isocele Area calculation.
*/
#include<stdio.h>
#include<string.h>
#include<math.h>
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
double r;
int n;
while( scanf( "%lf%d", &r, &n ) == 2 ){
// Angle between each two points for every point.
double PHI = ( double ) 360 / n ;
// For each Isosceles in the polygon the angle between the base and radius.
double THETA = (double) 90 - ( PHI / 2 );
// Convert Degree angle to Radian to use in code.
double THETA_RADIAN = THETA * M_PI / 180;
// a is base.
double a = 2 * r * cos( THETA_RADIAN );
// H is the height.
double h = r * sin( THETA_RADIAN );
// S represent Area of a single segment.
double S = (a * h) / 2;
// S * n is the are of complete polygon.
printf("%.3lf\n", S * n );
}
return 0;
}

This is an easier string problem. The task is to arrange the characters within the string in a certain order.

If the input string length is not square of a number then print INVALID. Ex: “DAVINCICODE” has length of 11. Squaring no number results in 11.

“DTFRIAOEGLRSI TS” has length of 16 including the space character. Square root of 16 is 4 and 4 * 4 is 16. So this is valid input.

Now if the input is valid then next task is to rearrange them. Instead of following given solution technique in the question it can solved much faster in another way. Following instruction in the question gives intuition that first the string must be positioned on 2 dimensional matrix in row major order. Then traverse them column by column.

A better way is find out each group length from square rooting the original string length. Next starting from first group take a character then skip by group length to get next column major character. After its done do this from the next character of first group.

Visualization:

Important:Be sure to add or print a new line after each output unless otherwise specified. The outputs should match exactly because sometimes even a space character causes the answer to be marked as wrong answer. Please compile with c++ compiler as some of my codes are in c and some in c++.

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 11716 - Digital Fortress
* Technique: Square String Traverse from row major
* to column major by skipping.
*/
#include<stdio.h>
#include<string.h>
#include<math.h>
#define N 10002
static char s[N];
static char output[N];
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
int n;
scanf("%d", &n);
getchar();
while( n-- ){
gets(s);
// Get the length of string and length of each string group.
int len = strlen(s);
int rc = sqrt(len);
// Reset in case there are characters from previous iteration.
memset(output, 0, sizeof output);
// If the string length can be divided into equal parts
// then traverse by skipping certain length.
if( rc * rc == len ){
int k = 0;
for( int j = 0; j < rc; ++j ){
for( int i = j; i < len; i = i + rc ){
output[k++] = s[i];
}
}
puts(output);
}
else{
puts("INVALID");
}
}
return 0;
}

This problem can be solved in quite a few ways. Brute force won’t work. I have given the brute force code anyway. It will give correct answer from 1 < n < 199999999 but the requirement is 1 < N < 1000000000, which is way way larger.

Another approach is to do mathematical calculation to come up with a formula to solve this. Multiple formula can be generated such as a single formula or, one formula complementing other or, multiple formula's combined. I have provided two formula in the codes below.

One thing to mention, the output or input must be long long data type. Other data types will give incorrect output.

Unfortunately I won’t be elaborate more than this. It took 5 pages to solve this many way with proof, but that’s a lot to write. I will try to explain a way for coming up with these formula.

The brute force way:

A simple way to do this is, for values greater than 1 set offset 10 and start multiplying with 5. For each step increase offset by 4 and add value to previous multiplying value.

Although this approach will not work since the range is huge. It is possible to pre-calculate for a certain range and anything outside that calculate with formula.

Trying to Come up with a Closed Form Expression:

First thing is to notice is that the numbers differ by 2 and are odd. So, if the first number is n, then the sum of n and next two numbers is,

Ex:
If n was 67, then result of 3n + 6 = 207.

The opposite is also true. For example, given sum of three numbers we can find the first number by,
if sum was 141 then,

Expanding and writing the sequence in format below,

Input – Values in the Row(Last three numbers bracketed) – Sum

Let n1 be equal to 1 and n2, n3 …, nk be next generated sequences. So the formula is,
n1 = n1
n2 = n1 + (1 * 2)
n3 = n2 + (3 * 2)
n4 = n3 + (5 * 2)
n5 = n4 + (7 * 2)
……………..
……………..
nk = n(k-1) + (i * 2)

this can be converted to an algorithm,
Let, T be table to store value of the first number.
n1 = 1
T[n1] = n1

i = 3

for i to size
T[i] = T[i-2] + (i-2) * 2
increment i by two
End

Generating Solution From the Output:

Similarly, The sum can also be calculated in terms of input by creating a sequence and finding out the formula.

The input for this formula is the input for the program,
for, n = 17 the sum of last three numbers should be 477.
Setting n = 17 in following the formula it will give,

The formula above doesn’t quite work out for 1. Although we know for 1 output is 1 but it should be included in the formula. Expanding and changing values the summation will get the formula for all values.

Similarly, this is the formula to calculate the first number to sum from a row. It was calculated making a sequence of first summing numbers and find out the the summation formula,

First number,

Separating the summation,

I won’t simplify anymore.

Put the value of summation in the equation,

because i only expanded the summation. Multiply result with 2 and add 3 to get the first number.

From, the equation above place the value of first number in 3n + 6 to get the summation of last three numbers for a given number.

The 3n + 6 and the summation formula can be combined into a single formula.

Generating Solution based on First Number of Last Three:

Similarly the first number to sum from every row can be calculated. If the first number from every row are written in a sequence,

1 + 3 + 13 + 27 + 45 + 67 + ………………..

The first number can be generated following this,

For input n = 11, task is to generate first number from the graphical representation above. Then the value can be placed in equation, 3N + 6 to generate sum of that value and next two (basically the answer).

For n = 15 the first number should be 123. Setting n = 15 in equation above,

first number = 3 + 10 * ( 7 – 1 ) + 2 * ( 7 – 2 ) * ( 7 – 1 )
first number = 3 + 60 + 60 = 123

That’s it. There are other approaches but it will take a long time to write.

Important:Be sure to add or print a new line after each output unless otherwise specified. The outputs should match exactly because sometimes even a space character causes the answer to be marked as wrong answer. Please compile with c++ compiler as some of my codes are in c and some in c++.

Formula Generate sequence sum, first number & sum Code:

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 913 Joana and Odd numbers
* Technique: Generate Sequence Sum, First number
* then generate sum of next numbers
* including the generated number.
*/
#include<stdio.h>
#include<string.h>
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
long long n;
while( scanf("%lld", &n) == 1 ){
long long m = n >> 1;
long long part = ( (n * (n + 1)) >> 1 ) - ( m * ( m + 1 ) ) - 4;
long long firstNum = 2 * part + 3;
printf("%lld\n", 3 * firstNum + 6);
}
return 0;
}

Reduced Formula Code:

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 913 Joana and Odd numbers
* Technique: Reduced formula.
*/
#include<stdio.h>
#include<string.h>
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
unsigned long long n;
while( scanf("%lld", &n) == 1 ){
long long ans = 3 * ( (n + 1) * ( n - (n >> 1) ) ) - 9;
printf("%lld\n", ans);
}
return 0;
}

Brute Force Code( Won’t be Accepted ):

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 913 - Joana and the odd numbers
* Technique: Brute Force. Won't get Accepted.
* This is just for demonstration. This
* won't get accepted due to huge size that
* array can't process. But it will give correct
* answer till N.
*/
#include<stdio.h>
#include<string.h>
#define N 100000000
//#define M 1000000000
static long long value[N];
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
value[0] = 1;
value[1] = 15;
long long offset = 30;
for( long long i = 2; i < N; ++i ){
value[i] = value[i-1] + offset;
offset = offset + 12;
}
long long n;
while( scanf("%lld", &n) == 1 ){
printf("%lld\n", value[n/2] );
}
return 0;
}

This problem is quite simple. Given two very large integers multiply them and print them. By large I mean almost 251 characters long for this problem. So string or character array must be used.

This problem can solved in many ways Big Integer, FFT, Grade School etc. But I have implemented lattice multiplication / Chinese multiplication to solve this problem.

Code Explanation:

The code below requires quite a bit of polish to understand easily ( A lot other post require the same. Maybe I will update this post sometimes in future or not. ).

This code is not quite space efficient. I have used several arrays to make it easy to understand but all of the tasks below can be done using the large array. Also the running time can further be improved to instead of . Where, m and n are length of two arrays and they may not be equal in size.

I have provided some graphical representations below to make it easier to understand.

This is an example of how the multiplication works in this code. As mentioned above the process can be sped up using rectangular matrix instead of square if the length is not equal.

This is a representation of how the table / square matrix is filled for further processing.

Multiplication starts with the last character of string 1 and proceeds to first character. For string 2 multiplication starts from the first character till last character. This way each character from string 1 and string 2 is first converted to a digit, then they are multiplied. If the result is two digits it is divided by 10.

The remainder is written as the lower left portion ( indicated by lower in the structure ) and the quotient is written as the upper left portion ( indicated by upper in the structure ).

This is graphical representation of how the structure is traversed. If you have trouble understanding how the recursive function traversing the structure, then take a look at UVA problem 264 – Count the Cantor Solution. The traversal is somewhat similar to that and I have provided explanation int that post.

Rest is explained in the code comments.

Important:Be sure to add or print a new line after each output unless otherwise specified. The outputs should match exactly because sometimes even a space character causes the answer to be marked as wrong answer. Please compile with c++ compiler as some of my codes are in c and some in c++.

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: Lattice Multiplication.
* Technique: High precision large number multiplication.
* Structure array representing upper left and
* and lower right corner in single cell.
*/
#include<stdio.h>
#include<string.h>
#define M 260
int N;
// Assuming both strings are of same length.
struct multiplicationTable{
int upper;
int lower;
};
struct multiplicationTable node[M][M];
static char string1[M];
static char string2[M];
// stores the diagonal sums;
int sum;
// decides whether to get the upper or lower
// value based on even or odd.
int m;
// Add diagonals.
int recursiveAdder( int i, int j ){
// Termination condition.
if( j < 0 || i >= N )
return sum;
int val;
// Whether to get the upper left corner or
// the lower right corner.
if( m % 2 ){
val = node[i][j].upper;
j = j - 1;
}
else{
val = node[i][j].lower;
i = i + 1;
}
++m;
// store the sum of the whole diagonal.
sum = sum + val;
// recursively visit all row ans column
// diagonally ( at least on pen and paper format ).
// actually moves more like the snake in the snakes game.
recursiveAdder(i,j);
return sum;
}
// Debug.
// Print the matrix showing the multiplications.
// Please note left and right directions may be different.
void printMultiplicationMatrix(){
printf("\n\n");
for( int i = 0; i < N; ++i ){
for( int j = N - 1; j >= 0; --j )
printf("%d,%d, ", node[i][j].upper, node[i][j].lower );
printf("\n");
}
}
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
while( gets(string1) ){
gets(string2);
int len1 = strlen(string1);
int len2 = strlen(string2);
// Fix length if both string are not equal size.
// Adding leading zeros to smaller string.
if( len1 > len2 ){
N = len1;
int shiftWidth = len1 - len2;
for( int i = len1 - 1; i >= 0; --i )
string2[i + shiftWidth] = string2[i];
for(int j = 0; j < shiftWidth; ++j)
string2[j] = '0';
}
else if(len2 > len1){
N = len2;
int shiftWidth = len2 - len1;
for( int i = len2 - 1; i >= 0; --i )
string1[i + shiftWidth] = string1[i];
for(int j = 0; j < shiftWidth; ++j)
string1[j] = '0';
}
else N = len1;
//printf("%s \n%s \n", string1, string2);
int k = N - 1;
// Multiply the numbers digit by digit and set in the lattice.
for( int i = 0; string2[i]; ++i ){
for( int j = 0; string2[j]; ++j ){
int num1 = string1[k] - '0';
int num2 = string2[j] - '0';
int multiply = num1 * num2;
node[j][k].upper = multiply / 10;
node[j][k].lower = multiply % 10;
}
--k;
}
//printMultiplicationMatrix();
// Lattice is divided into two parts upper left half and
// lower right half.
// result of upper half
int upperHalfResult[N];
// Add upper half
int i = N - 1;
for(; i >= 0; --i){
sum = 0;
m = 1;
upperHalfResult[i] = recursiveAdder(0, i);
}
// result of upper half
int lowerHalfResult[N];
// Add upper half
i = 0;
for(; i < N; ++i){
sum = 0;
m = 0;
lowerHalfResult[i] = recursiveAdder(i, N - 1);
}
// Combine upper and lower left half to a single array to fix addition
// problems.
int combinedRawResult[N + N];
i = 0;
for(; i < N; ++i )
combinedRawResult[i] = upperHalfResult[i];
for(k = 0; i < N + N; ++i, ++k )
combinedRawResult[i] = lowerHalfResult[k];
// If a cell has more than 9 then it should be added to the next cell.
for( int i = N + N - 1; i >= 0; --i ){
if( combinedRawResult[i] > 9 ){
combinedRawResult[i - 1] = combinedRawResult[i - 1] + combinedRawResult[i] / 10;
combinedRawResult[i] = combinedRawResult[i] % 10;
}
}
// Discard leading zeros.
for(i = 0; i < N + N; ++i)
if(combinedRawResult[i]) break;
// print if the result can be printed or its zero.
bool zero = true;
for(; i < N + N; ++i){
printf("%d", combinedRawResult[i]);
zero = false;
}
// If the result is zero.
if( zero )
printf("0");
printf("\n");
}
return 0;
}

The input is all possible combination of 3 bits. If A, B, C are thought as bits then possible binary combination are,

This problem can be solved in multiple ways such as using string, checking equality, performing xor equality etc. My code below is exactly same as equality checking but it perform xor operation between them.

XOR Table,

Important:Be sure to add or print a new line after each output unless otherwise specified. The outputs should match exactly because sometimes even a space character causes the answer to be marked as wrong answer. Please compile with c++ compiler as some of my codes are in c and some in c++.

The code won’t be exactly translated to MIPS code but similar code is written so the output is same as the c code.

C Code:

#include<stdio.h>
int main(){
int a = 2;
// Prints 20 in Hexadecimal which is equivalent to 32 in Decimal
printf("%x\n", a << 4);
return 0;
}

Let, $t0 represent a and $t1 represent the output value in Hex.

MIPS Code:

# This is Comment.
# $0 register is always 0.
ori $t0, $0, 2
sll $t1, $t0, 4

The first line of of MIPS code is or immediate. It can be used to load the value 2 into register $t0. Any value or’ed with another value is the same value. Remember $t0 in represents a in the C Code above.

The sll command shifts contents register $t0 by 4 bits. It is equivalent to, $t1 = $t1 << 4. 2 Shifted by 4 bits in decimal is 32 and in Hexadecimal is 20.

Code Execution in MARS:

No lines executed:

First Line executed:

Second Line executed:

Machine Language:

Here the first line of MIPS code ori is I-Format and the second line of code sll is R-type / Format instruction.

For the first line,

ori $t0, $0, 2

Machine Instruction in Binary:

Since ori is an I type instruction it will have 4 fields. It has opcode, rs, rt and immediate. $t0 is numbered 8, $0 register is 0. Opcode for ori is 13.

001101

00000

01000

0000000000000010

opcode

rs

rt

immediate

6 bits

5 bits

5 bits

16 bits

In order to convert the binary to Hex format instruction make group in 4 bits.

Machine Instruction Bits in Group of four:

0011 0100 0000 1000 0000 0000 0000 0010

which in Hexadecimal is,

0x34080002

It matches the instruction in the pictures above. Look at the codes column.

Similarly for the 2nd line,

sll $t1, $t0, 4

Machine Instruction in Binary:

Since ori is an I type instruction it will have 6 fields. It has opcode, rs, rt, rd, shamt (shift amount) and funct. Here rs is not used so set to 0. $t0 to $t7 registers are numbered from 8 to 15. So $t0 is numbered 8, $t1 is 9. The Opcode for sll ( Shift Left Logical ) is 0 and funct ( function ) is also 0.

000000

00000

01000

01001

00100

000000

opcode

rs

rt

rd

shamt

funct

6 bits

5 bits

5 bits

5 bits

5 bits

6 bits

In order to convert the binary to Hex format instruction again make group in 4 bits.

Machine Instruction Bits in Group of four:

0000 0000 0000 1000 0100 1001 0000 0000

which in Hexadecimal is,

0x00084900

Which again matches the instruction in the code column shown above.

Given a mine field that is a matrix / 2D array, produce an output that contains count of adjacent mines for each squares.

In a 2D array for each squares there are at most adjacent 8 squares. If the current position is i and j then,

Just traverse the matrix row-column wise and check its adjacent squares for getting mine count for current position. The adjacent squares check can be implemented with 8 if conditions for each one.

Another technique is to store the co-ordinates of adjacent squares and using a for loop to check them. The illustration below shows how the 2nd code is implemented using arrays and for loops,

Here the arrow from the center shows where checking starts. The 1D arrays drow and dcol hold the row and column values the way shown above. It can be changed by modifying drow and dcol arrays.

Important:Be sure to add or print a new line after each output unless otherwise specified. The outputs should match exactly because sometimes even a space character causes the answer to be marked as wrong answer. Please compile with c++ compiler as some of my codes are in c and some in c++.

Field #1:
*100
2210
1*10
1110
Field #2:
**100
33200
1*100

Code Using Multiple if Conditions:

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 10189 - Minesweeper
* Technique: 2D Array / Matrix Boundary checking using
* if conditions.
*/
#include<stdio.h>
#include<string.h>
#define MAXSIZE 101
static char MineField[MAXSIZE][MAXSIZE];
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
int n, m;
int FieldNumber = 0;
while( scanf("%d%d", &n, &m), n ){
getchar();
for(int i = 0; i < n; ++i)
scanf("%s", &MineField[i]);
if( FieldNumber )
printf("\n");
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j){
if( MineField[i][j] == '*' )
continue;
int temp = 0;
if( i + 1 < n && MineField[i + 1][j] == '*' )
++temp;
if( i + 1 < n && j + 1 < m && MineField[i + 1][j + 1] == '*' )
++temp;
if( j + 1 < m && MineField[i][j + 1] == '*' )
++temp;
if( i - 1 >= 0 && j + 1 < m && MineField[i - 1][j + 1] == '*' )
++temp;
if( i - 1 >= 0 && MineField[i - 1][j] == '*' )
++temp;
if( i - 1 >= 0 && j - 1 >= 0 && MineField[i - 1][j - 1] == '*' )
++temp;
if( j - 1 >= 0 && MineField[i][j - 1] == '*' )
++temp;
if( i + 1 < n && j - 1 >= 0 && MineField[i + 1][j - 1] == '*' )
++temp;
MineField[i][j] = temp + '0';
}
}
printf("Field #%d:\n", ++FieldNumber);
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j)
putchar(MineField[i][j]);
printf("\n");
}
}
return 0;
}

Code Bound checking using Array & for Loop:

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 10189 - Minesweeper
* Technique: 2D Array / Matrix Boundary checking using
* co-ordinate array and for loop.
*/
#include<stdio.h>
#include<string.h>
#define MAXSIZE 101
static char MineField[MAXSIZE][MAXSIZE];
// Co-ordinates / directions of adjacent 8 squares.
// W, SW, S, SE, E, NE, N, NW
static const int drow[] = {0, 1, 1, 1, 0, -1, -1, -1};
static const int dcol[] = {-1, -1, 0, 1, 1, 1, 0, -1};
int main(){
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
int n, m;
int FieldNumber = 0;
while( scanf("%d%d", &n, &m), n ){
getchar();
for(int i = 0; i < n; ++i)
scanf("%s", &MineField[i]);
if( FieldNumber )
printf("\n");
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j){
int temp = 0;
// If mine found do nothing.
if( MineField[i][j] == '*' )
continue;
// For each adjacent squares of the current square calculate mine count.
// and set the count in current square.
for(int k = 0; k < 8; ++k){
// Check if out of bound of the 2D array or matrix.
if( i + drow[k] < 0 || j + dcol[k] < 0 || i + drow[k] >= n || j + dcol[k] >= m )
continue;
// Check the appropriate co-ordinate for mine, if mine found increase count.
if( MineField[i + drow[k] ][j + dcol[k]] == '*' )
++temp;
}
// All adjacent squares checked set the mine count for current squares.
MineField[i][j] = temp + '0';
}
}
printf("Field #%d:\n", ++FieldNumber);
for(int i = 0; i < n; ++i){
for(int j = 0; j < m; ++j)
putchar(MineField[i][j]);
printf("\n");
}
}
return 0;
}

As a commenter below pointed out the solution is wrong due to the fact I made some wrong assumptions. Kindly check other sources for correct solution. This was accepted due to weak test cases. Also check udebug for different test cases.

Problem Statement Description:

Given input of where and three equations,

The task is to find values of x, y, z where x, y, z are three different integers which is ( x != y != z ). Meaning x can not be equal to y, t can not be equal to z and z can not be equal to x.

The problem asks to output the least value of x then y then z meaning the output will be in x < y < z order.

Things to notice:

One very important thing to notice is that for all three equation the values of x, y, z can be interchanged and it will still satisfy the problem.

For example,

then it can also be written as,

etc. all possible combinations. But the problem asks for least value of x then y then z.

So if after calculation the result is x = 9, y = 0, z = 5 which is supposed to be x = 0, y = 5, z = 9. In that case the values can be sorted which will result in x = 0, y = 5, z = 9 and this still satisfies the equations.

Solution Technique Explanation:

The simple approach to solve this problem is try all possible combinations of x, y, z and see if it produces a correct result.

The values of x, y, z being negative also satisfies this problem. Forgetting the value of negatives for the moment and focusing on the positive values. To get the naive loop count limit see x or y or z can be at least 0 and at most 100.

Same goes for the negative portion so looping for -100 to 100 for each 3 nested loops seem easy ( I haven’t given the 3 nested loop solution here. It can be found on other sites ). So from -100 to 0 to 100 there are 201 number in between. So naive solution requires 201*201*201 which is more than 8 million (8120601). This program should do 117 * 45 = 5265 iterations per test case.

This problem can be solve much faster using some algebraic substitution. Notice,

from equation (ii),

This can be rewritten as,

from equation (i),

substituting value of z from (iv) to (i) gives,

This can be rewritten as,

similarly from (iii) and (iv),

plugging in the value of z and solving for x and y,

Now from (v) and (vi),

Notice this equation above does not contain z. Now z can be calculated in terms of B, x, y.

This will completely remove one of the nested loops. Further improvements can be made by cutting down number of loop iterations.

Important point to notice that A, B, C can be at most 10000. Also x, y, z can differ by 1 and satisfy the equation. From above equations,

So if x, y, z differ by 1 then,

from equation (i),

but A can be at most 10000.

So, x = 3332.3333….

But to keep it simple, notice the lower order term 3 does not make much difference. By setting x = y = z the equation can be,

from equation (iii) since x is squared so it to get its iteration just calculate the square root. or, setting x = y = z and B = 10000 in equation (iii) gives,

after rounding of, x = 58

So the loop range for x is [-58…58].

Again from equation (ii) the iteration limit for y can be counted using x = y = z,

Rounded of to, y = 22

So iteration limit for y will be from [-22…22].

Calculating using y + 1 result in rounded range [-21…21]. Although I have not tested it.

Doing further algebraic simplification will remove another loop as z can be calculated in terms of A,B,C using,

where,

and,

using the main equation above, the value of z can be found and by solving the other equations the values of x and y can be calculated.

Also the loops can be input dependent. If max of A, B, C is bigger than 58 than choose 58 other wise choose the max as the loop counter.

There may be more improvements possible but that’s all I can come up with now. One final improvement can be made by breaking from all loops at once once the values are found. Although goto isn’t recommended c++ doesn’t support label to break out of multiple loops unlike java.

Important:Be sure to add or print a new line after each output unless otherwise specified. The outputs should match exactly because sometimes even a space character causes the answer to be marked as wrong answer. Please compile with c++ compiler as some of my codes are in c and some in c++.

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 11565 - Simple Equations
* Technique: Mathematical elimination and substitution
*/
#include<cstdio>
#include<algorithm>
#include<iostream>
int main(){
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
scanf("%d", &n);
int A, B, C;
while( n-- ){
scanf("%d%d%d", &A, &B, &C);
bool solutionFound = false;
int x, y, z;
for( x = -58; x <= 58; ++x ){
for( y = -22; y <= 22; ++y ){
if( x != y && ( (x * x + y * y) + (A - x - y) * (A - x - y) == C ) ){
int temp = x * y;
if( temp == 0 ) continue;
z = B / temp;
if( z != x && z != y && x + y + z == A ){
if(!solutionFound){
int tmpArray[3] = {x, y, z};
std::sort(tmpArray, tmpArray + 3);
std::cout << tmpArray[0] << " " << tmpArray[1] << " " << tmpArray[2] << "\n";
solutionFound = true;
break;
}
}
}
}
}
if(!solutionFound) std::cout << "No solution." << "\n";
}
return 0;
}

Optimized Code without goto:

/**
* Author: Asif Ahmed
* Site: https://quickgrid.wordpress.com
* Problem: UVA 11565 - Simple Equations
* Technique: Mathematical elimination and substitution
*/
#include<cstdio>
#include<algorithm>
#include<iostream>
int main(){
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
scanf("%d", &n);
int A, B, C;
while( n-- ){
scanf("%d%d%d", &A, &B, &C);
bool solutionFound = false;
int x, y, z;
for( x = -58; x <= 58; ++x ){
for( y = -22; y <= 22; ++y ){
if( x != y && ( (x * x + y * y) + (A - x - y) * (A - x - y) == C ) ){
int temp = x * y;
if( temp == 0 ) continue;
z = B / temp;
if( z != x && z != y && x + y + z == A ){
if(!solutionFound){
int tmpArray[3] = {x, y, z};
std::sort(tmpArray, tmpArray + 3);
std::cout << tmpArray[0] << " " << tmpArray[1] << " " << tmpArray[2] << "\n";
solutionFound = true;
goto done;
}
}
}
}
}
if(!solutionFound) std::cout << "No solution." << "\n";
done:;
}
return 0;
}

Here I am representing gray code bits with A, Decimal values with D and Binary bits with B.

Binary

Decimal

Gray Code

B3

B2

B1

B0

D

A3

A2

A1

A0

0

0

0

0

0

0

0

0

0

0

0

0

0

1

0

0

0

1

0

0

1

0

2

0

0

1

1

0

0

1

1

3

0

0

1

0

0

1

0

0

4

0

1

1

0

0

1

0

1

5

0

1

1

1

0

1

1

0

6

0

1

0

1

0

1

1

1

7

0

1

0

0

1

0

0

0

8

1

1

0

0

1

0

0

1

9

1

1

0

1

1

0

1

0

10

1

1

1

1

1

0

1

1

11

1

1

1

0

1

1

0

0

12

1

0

1

0

1

1

0

1

13

1

0

1

1

1

1

1

0

14

1

0

0

1

1

1

1

1

15

1

0

0

0

Binary to Gray Code Converter:

This same technique can be applied to make gray to binary converter. There will be 4 input bits, which represent binary and 4 output bits which represent equivalent gray code.

Since we are creating binary to gray code converter so, we need to find expressions for each gray code output in terms of input binary bits.

So, there will be four output bits . For these output bits the input will be different combinations of based on minimized expression.

Karnaugh Maps:

A_{3}:

Minimized expression from the above k map,

A_{2}:

Minimized expression from the above k map,

But, the expression of XOR Gate is (Let, A and B be the inputs),

[Note: This is not related to this problem but, only showing how XOR can be made from And, Or, Not gates]

Similarly,it can be shown that,

If XOR gate is not available then the former expression can be used with and, or and not gates to design the gray code converter.

Difference of gray code from binary is that, for each group only one bit changes when going from one number to the next. In case of binary it can be seen from the table that multiple bit may change when going from one number to next.

How to Create Gray Code Sequence:

There are multiple shortcut technique to write gray code. This is the technique I follow,

First start with,

0
1

Next step, Add 0’s before both of them,

0 | 0
0 | 1

Next Mirror ( Write the values bottom to top instead of top to bottom ) all bits except for Left Most bit and Add 1’s in the place left most bit,

0 | 0
0 | 1
------> Mirror
1 | 1
1 | 0

Continuing this process again of adding 0’s before all numbers and Mirroring all bits except left most bit, then adding 1’s in place of left most bit,

Now just start from the top with 0 and increment it by 1. That will be the decimal equivalent of the gray code.

Binary, Decimal and Gray Code Table:

Here I am representing gray code bits with A, Decimal values with D and Binary bits with B.

Binary

Decimal

Gray Code

B3

B2

B1

B0

D

A3

A2

A1

A0

0

0

0

0

0

0

0

0

0

0

0

0

0

1

0

0

0

1

0

0

1

0

2

0

0

1

1

0

0

1

1

3

0

0

1

0

0

1

0

0

4

0

1

1

0

0

1

0

1

5

0

1

1

1

0

1

1

0

6

0

1

0

1

0

1

1

1

7

0

1

0

0

1

0

0

0

8

1

1

0

0

1

0

0

1

9

1

1

0

1

1

0

1

0

10

1

1

1

1

1

0

1

1

11

1

1

1

0

1

1

0

0

12

1

0

1

0

1

1

0

1

13

1

0

1

1

1

1

1

0

14

1

0

0

1

1

1

1

1

15

1

0

0

0

Making Decimal to Gray Converter:

Since this is Decimal to Gray Code converter, the Binary part of the table could be omitted.

Let,

From the above expression,

Inputs and Outputs:

For the circuit there will be inputs each representing a decimal number. The number of outputs will be 4 from where, .

How to test if its working:

Just press each buttons in the left one at a time then check to see if the values given match the value in table. The values are read bottom to top, equivalent to reading values from table left to right.