int main()
{
int t,n,i,res,q,l1,l2,p,s;
t=get_int();
while(t--){
n=get_int();
q=get_int();
for(i=0;i<n;i++)
a[i]=get_int();
while(q--)
{
p=s=0;
l1=get_int();
l2=get_int();
for(i=0;i<l1-1;i++)
p=findGCD(p,a[i]);
for(i=l2;i<n;i++)
s=findGCD(s,a[i]);
writeInt(findGCD(p,s));
}
}
return 0;
}
//main function
int main(void){
//variables for main function
char *yes = "y";
char *no = "n";
int progcontinue = 0;
int continuetest = 0;
printf("Brian Sator, masc0916\n\n");//output program setup information
for(;;){
//at the beginning of each cycle we check to see if we need to run the main routine again
if(progcontinue != 0){
break;//exit loop
}
printf("Please enter a fraction to reduce: ");//prompt user
scanf("%25s",buffer1);//read from input
flushinstream();//flush the input stream
if(in_validate(buffer1) == 1){//the input string is a valid fraction proceed with reduction
int numtest = atoi(num);
int denomtest = atoi(denom);
negative = is_negative(numtest, denomtest);
commondivisor = abs(findGCD(numtest,denomtest));
numtest = abs(numtest/commondivisor);
denomtest = abs(denomtest/commondivisor);
if(negative == 0){//check if negative
printf("The reduced fraction is: %d/%d\n\n",numtest, denomtest);
}else{
printf("The reduced fraction is: -%d/%d\n\n",numtest, denomtest);
}
numtest = 0;
numtest = 0;
}
else{//the input string is not valid, start routine over to prompt for new input
continue;
}
while(continuetest == 0){//here we check to see if user wants to reduce another fraction
printf("Do you want to reduce another fraction(y/n)? ");
scanf("%25s",buffer1);
flushinstream();
if(buffer1[0] == *no){//end program
progcontinue = 1;
continuetest = 1;
}else if(buffer1[0] == *yes){//new fraction
continuetest = 1;
}
else{//invalid input
printf("Sorry, invalid input\n\n");
}
}
continuetest = 0;
memset(num,0,30);
memset(denom,0,30);
}
printf("Program Terminated\n");
return 0;//exit program
}
int findGCD(int a, int b)
{
if (b)
return findGCD(b, a % b);
else
return a;
}
//find the GCD of the fraction, this is a recursive method
int findGCD(int a, int b){
if(b == 0){
return a;
}
else{
return findGCD(b, a%b);
}
}
int findGCD(int a, int b) {
a = abs(a);
b = abs(b);
if (b == 0){
return a;
}
else {
findGCD(b, a % b);
}
}
void Rational (int n, int d) {
if(d < 0) {
n = (n * -1);
d = (d * -1);
}
int gcd = findGCD(n, d);
n = n / gcd;
d = d / gcd;
}
// finds the greatest common denominator with 2 given numbers
int findGCD(int a, int b)
{
// variable for remainder of the two numbers
int remainder;
// if the remainder is zero, the 2nd number is the gcd
if((remainder = b % a) == 0)
return a;
else // else try to find the gcd with the remainder
findGCD(remainder, b);
}
// simplifies a given fraction
void simplify(int *num, int *denom)
{
// vairalbes for simplified numerator and denominator, and greatest common denominator
int simpNum, simpDenom, gcd;
// if numbers are the same, return 1
if(*num == *denom)
*num = 1, *denom = 1;
else // else find the greatest common denominator
{
gcd = findGCD(*num, *denom);
*num /= gcd;
*denom /= gcd;
}
}
void BigRational::init(const BigInt &numerator, const BigInt &denominator) {
DEFINEMETHODNAME;
if(denominator.isZero()) {
throwInvalidArgumentException(method, _T("Denominator is zero"));
}
DigitPool *pool = getDigitPool();
if(numerator.isZero()) { // zero always 0/1
m_numerator = pool->get0();
m_denominator = pool->get1();
} else {
const BigInt gcd = findGCD(BigInt(fabs(numerator)),BigInt(fabs(denominator)));
m_numerator = numerator / gcd;
m_denominator = denominator / gcd;
if(denominator.isNegative()) { // Negative numbers are represented with negative numerator and positive denominator
m_numerator = -m_numerator;
m_denominator = -m_denominator;
}
}
}
int main(void)
{
DDRA = 0xFF; PORTA = 0x00;
DDRB = 0xFF; PORTB = 0x00;
DDRC = 0xF0; PORTC = 0x0F;
DDRD = 0xFF; PORTD = 0x00;
//period for the tasks
unsigned long int GameTask_per = 50;
unsigned long int Keypad_per = 50;
unsigned long int GameOfSnakeEasy_per = 400;
unsigned long int UpdateMatrix_per = 1;
unsigned long int GenerateFruit_per = 50;
unsigned long int GameOfSnakeNormal_per = 200;
unsigned long int GameOfSnakeHard_per = 200;
unsigned long int SpeakerTick_per = 3;
//Calculating GCD
unsigned long int tmpGCD;
tmpGCD = findGCD(Keypad_per,GameOfSnakeEasy_per);
tmpGCD = findGCD(tmpGCD,UpdateMatrix_per);
tmpGCD = findGCD(tmpGCD,GenerateFruit_per);
tmpGCD = findGCD(tmpGCD,GameTask_per);
tmpGCD = findGCD(tmpGCD,GameOfSnakeNormal_per);
tmpGCD = findGCD(tmpGCD,GameOfSnakeHard_per);
//Greatest common divisor for all tasks or smallest time unit for tasks.
unsigned long int GCD = tmpGCD;
//Recalculate GCd periods for scheduler
unsigned long int GameTask_period = GameTask_per/GCD;
unsigned long int Keypad_period = Keypad_per/GCD;
unsigned long int GameOfSnakeEasy_period = GameOfSnakeEasy_per/GCD;
unsigned long int UpdateMatrix_period = UpdateMatrix_per/GCD;
unsigned long int GenerateFruit_period = GenerateFruit_per/GCD;
unsigned long int GameOfSnakeNormal_period = GameOfSnakeNormal_per/GCD;
unsigned long int GameOfSnakeHard_period = GameOfSnakeHard_per/GCD;
long double SpeakerTick_period = SpeakerTick_per/GCD;
//Declare an array of tasks
static task task0, task1, task2, task3, task4, task5, task6, task7;
task *tasks[] = {&task0, &task1, &task2, &task3, &task4, &task5, &task6, &task7};
const unsigned short numTasks = sizeof(tasks)/sizeof(task*);
//Task 0
task0.state = -1;
task0.period = GameTask_period;
task0.elapsedTime = GameTask_period;
task0.TickFct = &GameTask;
//Task 1
task1.state = -1;
task1.period = Keypad_period;
task1.elapsedTime = Keypad_period;
task1.TickFct = &GetKeyPress;
//Task 2
task2.state = -1;
task2.period = GameOfSnakeEasy_period;
task2.elapsedTime = GameOfSnakeEasy_period;
task2.TickFct = &GameOfSnakeEasy;
//Task 3
task3.state = -1;
task3.period = UpdateMatrix_period;
task3.elapsedTime = UpdateMatrix_period;
task3.TickFct = &UpdateMatrix;
//Task 4
task4.state = -1;
task4.period = UpdateMatrix_period;
task4.elapsedTime = UpdateMatrix_period;
task4.TickFct = &GenerateFruit;
//Task 5
task5.state = -1;
task5.period = GameOfSnakeNormal_period;
task5.elapsedTime = GameOfSnakeNormal_period;
task5.TickFct = &GameOfSnakeNormal;
//Task 6
task6.state = -1;
task6.period = GameOfSnakeHard_period;
task6.elapsedTime = GameOfSnakeHard_period;
task6.TickFct = &GameOfSnakeHard;
//Task 7
task7.state = -1;
task7.period = SpeakerTick_period;
task7.elapsedTime = SpeakerTick_period;
task7.TickFct = &Speaker_Func;
TimerSet(GCD);
TimerOn();
unsigned short i;
gameTaskState = -1;
KeyState = -1;
GameStateEasy = -1;
GameStateNormal = -1;
GameStateHard = -1;
UpdateState = -1;
Fruit_Status = -1;
dir = -1;
while(1)
{
for (i=0; i < numTasks; i++)
{
if (tasks[i]->elapsedTime == tasks[i]->period)
{
tasks[i]->state = tasks[i]->TickFct(tasks[i]->state);
tasks[i]->elapsedTime = 0;
}
tasks[i]->elapsedTime += 1;
}
while(!TimerFlag);
TimerFlag = 0;
}
return 0;
}
int main(void)
{
DDRA = 0xFF; PORTA = 0x00;
DDRB = 0xFF; PORTB = 0x00;
DDRC = 0x00; PORTC = 0xFF;
DDRD = 0xFF; PORTD = 0x00;
//DDRD = 0xFF; PORTD = 0x00;
//period for the tasks
unsigned long int LI_per = 4;
unsigned long int LT_per = 2;
unsigned long int ScoreTask_per = 5;
unsigned long int ResetTask_per = 5;
unsigned long int StartTask_per = 5;
unsigned long int EasyTask_per = 5;
unsigned long int NormalTask_per = 5;
unsigned long int HardTask_per = 5;
unsigned long int LoseTask_per = 5;
//Calculating GCD
unsigned long int tmpGCD = 1;
tmpGCD = findGCD(LI_per,LT_per);
tmpGCD = findGCD(tmpGCD,ScoreTask_per);
//Greatest common divisor for all tasks or smallest time unit for tasks.
unsigned long int GCD = tmpGCD;
//Recalculate GCd periods for scheduler
unsigned long int LI_period = LI_per/GCD;
unsigned long int LT_period = LT_per/GCD;
unsigned long int ScoreTask_period = ScoreTask_per/GCD;
unsigned long int ResetTask_period = ResetTask_per/GCD;
unsigned long int StartTask_period = StartTask_per/GCD;
unsigned long int EasyTask_period = EasyTask_per/GCD;
unsigned long int NormalTask_period = NormalTask_per/GCD;
unsigned long int HardTask_period = HardTask_per/GCD;
unsigned long int LoseTask_period = LoseTask_per/GCD;
//Declare an array of tasks
static task task1, task2, task3, task4, task5, task6, task7, task8, task9;
task *tasks[] = {&task1, &task2, &task3, &task4, &task5, &task6, &task7, &task8, &task9};
const unsigned short numTasks = sizeof(tasks)/sizeof(task*);
//Task 1
task1.state = -1;
task1.period = LI_period;
task1.elapsedTime = LI_period;
task1.TickFct = &LI_Tick;
//Task 2
task2.state = -1;
task2.period = LT_period;
task2.elapsedTime = LT_period;
task2.TickFct = <_Tick;
//Task3
task3.state = -1;
task3.period = ScoreTask_period;
task3.elapsedTime = ScoreTask_period;
task3.TickFct = &ScoreTask;
//Task4
task4.state = -1;
task4.period = ResetTask_period;
task4.elapsedTime = ResetTask_period;
task4.TickFct = &ResetTask;
//Task5
task5.state = -1;
task5.period = StartTask_period;
task5.elapsedTime = StartTask_period;
task5.TickFct = &StartTask;
//Task6
task6.state = -1;
task6.period = EasyTask_period;
task6.elapsedTime = EasyTask_period;
task6.TickFct = &EasyTask;
//Task7
task7.state = -1;
task7.period = NormalTask_period;
task7.elapsedTime = NormalTask_period;
task7.TickFct = &NormalTask;
//Task8
task8.state = -1;
task8.period = HardTask_period;
task8.elapsedTime = HardTask_period;
task8.TickFct = &HardTask;
//Task9
task9.state = -1;
task9.period = LoseTask_period;
task9.elapsedTime = LoseTask_period;
task9.TickFct = &LoseTask;
TimerSet(GCD);
TimerOn();
unsigned short i;
LI_State = -1;
LT_State = -1;
ScoreState = -1;
ResetState = -1;
StartState = -1;
EasyState = -1;
NormalState = -1;
HardState = -1;
LoseState = -1;
while(1)
{
for (i=0; i < numTasks; i++)
{
if (tasks[i]->elapsedTime == tasks[i]->period)
{
tasks[i]->state = tasks[i]->TickFct(tasks[i]->state);
tasks[i]->elapsedTime = 0;
}
tasks[i]->elapsedTime += 1;
}
while(!TimerFlag);
TimerFlag = 0;
}
return 0;
}
int main(void)
{
DDRA = 0xF0; PORTA = 0x0F; // PORTA[3:0]: IN -- KP rows
// PORTA[7:4]: OUT -- select KP Columns
DDRB = 0xFF; PORTB = 0x00; // PORTB: out -- LEDs
DDRC = 0xFF; PORTC = 0x00;
DDRD = 0xFF; PORTD = 0x00; // PORTD[0:3] LEDs
// PORTD[4:5] Unused
// PORTD[6:7] LCD
// Period for the tasks
unsigned long int ReadKeypadSM_calc = 50;
unsigned long int displayKPInputSM_calc = 100;
//Calculating GCD
unsigned long int GCD = 1;
GCD = findGCD(ReadKeypadSM_calc, displayKPInputSM_calc);
//recalculate GCD periods for scheduler
unsigned long ReadKeypadSM_period = ReadKeypadSM_calc/GCD;
unsigned long displayKPInputSM_period = displayKPInputSM_calc/GCD;
// Declare an array of tasks
static task task1, task2;
task *tasks[] = {&task1, &task2};
const unsigned short numTasks = sizeof(tasks)/sizeof(task*);
//Task 1
task1.state = -1;
task1.period = ReadKeypadSM_period;
task1.elapsedTime = ReadKeypadSM_period;
task1.TickFct = &ReadKeypadSMtick;
//Task 2
task2.state = -1;
task2.period = displayKPInputSM_period;
task2.elapsedTime = displayKPInputSM_period;
task2.TickFct = &displayKPInputSMtick;
//Set Timer and turn on
TimerSet(GCD);
TimerOn();
//Init LCD
LCD_init();
LCD_DisplayString(1, "Welcome to the breadboard!");
//scheduler for loop iterator
unsigned short i;
while(1)
{
for(i = 0; i < numTasks; i++){
// task is ready to tick
if(tasks[i]->elapsedTime == tasks[i]->period){
// Setting next state for task
tasks[i]->state = tasks[i]->TickFct(tasks[i]->state);
// Reset elapsed time for next tick.
tasks[i]->elapsedTime = 0;
}
tasks[i]->elapsedTime += 1;
}
while(!TimerFlag);
TimerFlag = 0;
}
return 0;
}
